Im Microsoft .NET Framework ist schon lange eine Funktion zum Kürzen von Dateinamen enthalten. Aus c:\Windows\System32\MyDll.dll kann dann zum Beispiel c:\Windows\…\MyDll.dll werden. Hierzu greift man auf TextRenderer.MeasureText zurück. Allerding hat diese Funktion einen kleinen Fehler bei dem zurückgegebenen Wert, der hier beschrieben ist:
Der Workaround ist zum Glück auch gleich angegeben, und kann dann so aussehen:
string filename = string.Copy(filenameForOutput);
if (!string.IsNullOrEmpty(filename))
{
TextRenderer.MeasureText(filename, Font, Size,
TextFormatFlags.PathEllipsis | TextFormatFlags.ModifyString);
filename = filename.Substring(0, filename.IndexOf('\0'));
}Der Source zeigt auch gleich noch eine kleine andere Ergänzung: Die Funktion modifiziert den übergebenen String. Man sollte diesen also vorher kopieren, sofern man nicht schon mit einer Kopie des Strings arbeitet.
Eine Abfrage im SQL Server enthält eine time-Spalte:
SELECT [Activity], [Duration] FROM TableName
Die Aufgabenstellung bestand darin, die Zeiten zu addieren. Leider wurde dieser Versuch
SELECT SUM([Duration]) FROM TableName
abgelehnt:
Der Operanddatentyp time ist für den sum-Operator ungültig.
was zwar nicht einleuchtend, aber auch nicht zu ändern war.
Die Lösung war die vorherige Umwandlung der Zeit in eine Datumsdifferenz vom Typ Minuten:
SELECT SUM(DATEDIFF(MINUTE, '00:00:00', [Duration])) FROM TableName
Glaubt man der Dokumentation von HttpRequest.ApplicationPath, so ist es recht einfach, einen Link in einer eigenen Asp.NET Seite zu verwenden:
Label1.Text = Request.ApplicationPath;
Image1.ImageUrl = Request.ApplicationPath + "/images/Image1.gif";
Label2.Text = Image1.ImageUrl;
Aber damit steht man schnell vor einem Problem: Liegt die Anwendung im Root, wie es beispielsweise standardmäßig beim Visual Studio 2010 Development Server der Fall ist, so erhält man als Ergebnis nur ein /. Die korrekte Zeile wäre dann also:
Image1.ImageUrl = Request.ApplicationPath + "images/Image1.gif";
Befindet sich die Seite aber in einem virtuellen Verzeichnis, so kommt das Verzeichnis ohne abschließenden / zurück:
Image1.ImageUrl = Request.ApplicationPath + "/images/Image1.gif";
Je nach Speicherort muss man also beim händischen Zusammensetzen der URL’s also den abschließenden Slash berücksichtigen, oder eben auch nicht.
Eine gute Lösung habe ich in einem Blog-Artikel von 2004 gefunden:
VirtualPathUtility.ToAbsolute("~/images/Image1.gif")Damit überlässt man Asp.NET die korrekte Umsetzung, welche auch tadellos und ohne Experimente funktioniert!
Update:
Manchmal sieht man einfach den Wald vor lauter Bäumen nicht. Die kürzere Lösung ist Url.Content, welche ein vergleichbares Ergebnis liefert und auch in den Templates von Asp.NET MVC3 verwendet wird.
Für eine Erweiterung von meinem Quellcode hatte ich geplant, ein paar Properties mit Attributen zu versehen. Dabei sollten die Properties virtual sein. Die Abfrage der Attribute sollte dann mittels GetCustomAttributes geschehen. Leider hat das gar nicht funktioniert, was auch schon andere .NET-Programmierer feststellen mussten. Darum habe ich die Problemstellung extrahiert:
Zum Prüfen der Attribute wurde folgende Funktion verwendet:
static void CheckAttribute(MemberInfo memberInfo)
{
var attributes = memberInfo.GetCustomAttributes(true);
if (attributes.Length == 0) return;
foreach (object attribute in attributes)
Console.WriteLine("The type of the attribute in {1} is {0}.",
attribute, memberInfo.Name);
}Weiterhin wurden zwei Klassen geschrieben, wo einmal eine abgeleitete Methode und eine abgeleitete Propertie mit Attributen versehen wurde:
public abstract class BaseClass
{
[TestAttribute]
public virtual String TestProperty { get; set; }
[TestAttribute]
public virtual void TestMethod() { return; }
}
public class DerivedClass : BaseClass
{
public override string TestProperty { get; set; }
public override void TestMethod() { base.TestMethod(); }
}
public class TestAttribute : Attribute
{
}Zu guter Letzt wurde das ganze überprüft:
Console.WriteLine("BaseClass:");
CheckAttribute(typeof(BaseClass).GetProperty("TestProperty"));
CheckAttribute(typeof(BaseClass).GetMethod("TestMethod"));
Console.WriteLine("DerivedClass:");
CheckAttribute(typeof(DerivedClass).GetProperty("TestProperty"));
CheckAttribute(typeof(DerivedClass).GetMethod("TestMethod"));Das Ergebnis fiel überraschend aus:
BaseClass:
The type of the attribute in TestProperty is TestAttrib.TestAttribute.
The type of the attribute in TestMethod is TestAttrib.TestAttribute.
DerivedClass:
The type of the attribute in TestMethod is TestAttrib.TestAttribute.
Wähernd die Methode TestMethod in beiden Klassen als mit dem Attribut ausgezeichnet, erkannt wurde, war dies bei der Eigenschaft TestProperty nicht der Fall. Um die Ursache zu finden, war ein Blick in die IL notwendig. Hier die Umsetzung der BaseClass, welche das Attribute in beiden Fällen korrekt definiert.
.method public hidebysig newslot virtual instance void TestMethod() cil managed
{
.custom instance void TestAttrib.TestAttribute::.ctor()
}
.property instance string TestProperty
{
.get instance string TestAttrib.BaseClass::get_TestProperty()
.set instance void TestAttrib.BaseClass::set_TestProperty(string)
.custom instance void TestAttrib.TestAttribute::.ctor()
}Die Ableitung war aber überaschend umgesetzt. Während die Methode offensichtlich überschrieben wurde, wurde die Propertie quasi neu angelegt, aber ohne dem zugewiesenen Attribut.
.method public hidebysig virtual instance void TestMethod() cil managed
{
}
.property instance string TestProperty
{
.get instance string TestAttrib.DerivedClass::get_TestProperty()
.set instance void TestAttrib.DerivedClass::set_TestProperty(string)
}Damit war das Ergebnis der Untersuchung: GetCustomAttributes hat definitionsgemäß auch die Ableitungen untersucht. Jedoch verlieren sich die Attribute beim Überschreiben von Properties. Eine Erklärung dafür habe ich bis jetzt nicht gefunden, ich konnte den Effekt aber in .NET 2.0 – 4.0 nachstellen.
Die Webseite dotnet-snippets.de wird 5 Jahre alt. Herzlichen Glückwunsch!
Wer die Seite noch nicht kennt, aber mit Microsoft .NET entwickelt, sollte einfach mal vorbeischauen. Es gibt viele kurze hilfreiche Codeschnipsel zu den meisten Problemchen, die man so im täglichen Leben hat.
Für eine Funktionalität auf einem Buildserver wurde ein Skript benötigt, dass in der Lage ist, Archive zu erstellen. Ein idealer Anwendungsfall für Powershell, wenn man erst einmal ein paar wichtige Sachen erkannt hat.
Das Skript soll zwei Parameter empfangen. Der erste Parameter $destname enthält lediglich den Zielnamen des Archiv’s. Der zweite Parameter $source ist der Ordner, wo alle zu packenden Dateien abgelegt sind. {dest} und {temp} sind Platzhalter fester Pfade für das zu erstellende Archiv und temporäre Dateien.
param ([string] $destname, [string] $source)
$path = "{dest}\" + $destname + ".zip"
$temp = "{temp}"Um das Skript einfach einsetzen zu können, sollte in Powershell kein Modul mehr nachinstalliert werden müssen. Darum wurde auf die Funktionalität der gepackten Ordner von Windows zurückgegriffen. Diese gibt es schon geraume Zeit im Standard-Lieferumfang. Um diesen Ordner nutzen zu können, erstellt man ein leeres Archiv mittels einer kleinen Bytefolge, dass dann einfach wie ein Ordner angesprochen wird (mittels des COM-Objektes Shell.Application):
Set-Content $path ("PK" + [char]5 + [char]6 + ("$([char]0)" * 18))
$ShellApp = New-Object -ComObject Shell.Application
$ZipPackage = $ShellApp.Namespace($path)Dieser Zwischenschritt löscht dem temporären Ordner und kopiert eine Auswahl von Dateien aus dem Quellverzeichnis in den frisch erstellen temporären Ordner:
rmdir $temp -Recurse -Force
mkdir $temp
$files = Get-ChildItem -Path $($source + "\*") -Include *.exe,*.dll | Copy-Item -Destination $temp
mkdir $($temp + "\Data")
$files = Get-ChildItem -Path $($source + "\Data\*") -Include *.* | Copy-Item -Destination $($temp + "\Data")
Der letze Schritt war der schwerste: Als erstes wird der komplette temporäre Ordner einfach in das Archiv kopiert. Leider ist dieser Vorgang asynchron. Beendet man jetzt das Skript und die Powershell, so wird der Vorgang auch mit abgebrochen. Also muss man mittels Sleep solange warten, bis das Archiv garantiert erstellt ist. Diese Krücke ist zwar unbefriedigend, aber leider ist mir dafür keine alternative Lösung eingefallen:
$ZipPackage.CopyHere($temp, 4)
Start-Sleep -s 15
In einem Backup-Ordner stand die Aufgabe an, alte Dateien automatisch löschen zu lassen. Dazu wurde folgendes Skript eingesetzt:
Get-ChildItem -Path . |
Where-Object -FilterScript {($_.LastWriteTime -lt [DateTime]::Now.AddDays(-7))} |
Remove-Item -forceZuerst werden alle relevanten Dateien ermittelt. Danach wird auf diese Liste ein Filter gesetzt, der nur Dateien ermittelt, die älter als 7 Tage sind. Hierzu wird eine Rückgriff auf DateTime aus dem Net-Framework genutzt. Es bietet mit Now und AddDays die gewünschte Funktionalität, von jetzt 7 Tage nach hinten zu gehen. Als letzten Schritt muss die ermittelte Liste lediglich an Remove-Item weitergereicht werden.
Beim Ausführen einer Powershell-Datei erhielt ich im Protokoll neulich folgende bekannte Fehlermeldung, obwohl Set-ExecutionPolicy auf RemoteSigned gesetzt war:
Die Datei "...test.ps1" kann nicht geladen werden, da die Ausführung
von Skripts auf diesem System deaktiviert ist. Weitere
Informationen erhalten Sie mit "get-help about_signing".
Bei Zeile:1 Zeichen:2
+ . <<<< '...test.ps1'
+ CategoryInfo : NotSpecified: (:) [], PSSecurityException
+ FullyQualifiedErrorId : RuntimeException
Die Lösung lag letztendlich darin, dass das entsprechende Skript auf einem 64Bit-System als 32Bit-Task aufgerufen wurde. Es war ausreichend, Set-ExecutionPolicy unter Powershell (x86) ebenfalls aufzurufen und entsprechend zu setzen.
Seit einigen Tagen versuche ich das Servicepack 1 (KB976932) von Windows 7 zu installieren. Immer ohne Erfolg. Der Vorgang startet ganz normal, aber beim Neustart des Rechners läuft die Konfiguration zügig auf 99% hoch, bevor ein Fehler auftritt und alles wieder rückgängig gemacht wird.
Da das ganze ca. eine Stunde dauert, ist jeder Test schwierig und einfach aufwändig. Im Ereignisprotokoll oder WindowsUpdate.log waren leider keine sinnvollen Hinweise zu finden, lediglich kurz nach dem Hochfahren wird der Fehlercode 8004402F angezeigt. Ein ähnliches Problem brachte dann auch noch die Installation vom Internet-Explorer 9.
Glücklicherweise habe ich heute einen recht alten Blog-Beitrag für Windows Vista gefunden, der dann auch half. Mein %TEMP% Ordner war auf Laufwerk D umgestellt. Dieses Laufwerk ist aber ein verschlüsseltes TrueCrypt-Laufwerk, was beim Neustart nicht zur Verfügung steht. Ich habe diesen Ordner wieder auf eine unverschlüsselte Festplatte umgelenkt, und die Installation war erfolgreich.
Schade, dass hier nirgends ein entsprechender Fehler ausgegeben wird. Beim Starten der Installation hätte mir der Hinweis auf einen nicht verfügbaren Temp-Ordner viele Stunden der Suche erspart.
Mit PostSharp bekommt man eine mächtige Möglichkeit, Code mittels Attributen aufzupeppen. So wird man auch in die Lage versetzt, wiederkehrenden Code zu vermeiden. Üblicherweise sieht nämlich beispielsweise eine Implementation von System.ComponentModel.INotifyPropertyChanged wie folgt aus:
public class Test: System.ComponentModel.INotifyPropertyChanged
{
private string _myProp;
public string MyProp
{
get { return _myProp; }
set
{
if (_myProp == value) return;
_myProp = value;
OnPropertyChanged("MyProp");
}
}
public event PropertyChangedEventHandler PropertyChanged;
public void OnPropertyChanged(string propertyName)
{
if (this.PropertyChanged != null)
{
this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
}Verwendet man jedoch PostSharp als Referenz in seinem Projekt und die Klasse NotifyPropertyChangedAttribute aus
{ProgramFiles}\PostSharp 2.0\Samples\.NET Framework 3.5\CSharp\NotifyPropertyChanged
kann man seinen Code merklich verkürzen:
[NotifyPropertyChanged]
public class TestBase
{
public string MyProp { get; set; }
}Problem
Leider ergibt letztere Implementation das Problem, dass ich die Kontrolle über das Auslösen von Events vollständig an das Attribut NotifyPropertyChanged abgebe. Da der Code für das Event nachträglich in das Compilat injiziert wird, ergibt sich keine Möglichkeit, das Event PropertyChanged manuell auszulösen, da .NET das Auslösen von Events nur innerhalb der implementierenden Klasse erlaubt. Versuche, Zugriff auf das Event durch Vorimplementierung des Interfaces zu erhalten, helfen leider auch nicht, da der durchs Attribut erzeugte Code in einer Property der Klasse zusätzlich angelegt wird. Dies kann man leicht mit dem Reflektor prüfen:
public string MyProp
{
[CompilerGenerated]
get
{
return this.<get_MyProp>();
}
[CompilerGenerated]
set
{
LocationInterceptionArgsImpl<string> CS$0$1 = new LocationInterceptionArgsImpl<string>(this, Arguments.Empty);
CS$0$1.Location = <>z__Aspects.l3;
CS$0$1.TypedBinding = <MyProp>c__Binding.singleton;
CS$0$1.TypedValue = value;
this.<>z__aspect0.OnPropertySet(CS$0$1);
}
}Das Setzen der per Attribut erweiterten Property wird beispielsweise komplett auf z__apect0 umgeleitet. Und an genau dieses z__apect0 ist ja zur Entwurfszeit noch nicht verfügbar (das ist ja der Sinn des Attributes).
Umgehen konnte ich das Problem mit einer kleiner Erweiterung des NotifyPropertyChangedAttribute:
[ImportMember("ManualPropertyChanged", IsRequired = false,
Order = ImportMemberOrder.AfterIntroductions)]
public Event<PropertyChangedEventHandler> ManualPropertyChanged;
public override void RuntimeInitializeInstance()
{
base.RuntimeInitializeInstance();
if (ManualPropertyChanged != null)
ManualPropertyChanged.Add((sender, args) =>
{ if (PropertyChanged != null) PropertyChanged(Instance, args); });
}Bietet meine Klasse, welche das NotifyPropertyChangedAttribute ausweist, folgendes Ereignis an:
public event PropertyChangedEventHandler ManualPropertyChanged;
so abonniert das Attribut dieses Ereignis und sorgt beim Auslösen von ManualPropertyChanged automatisch für eine Weiterleitung an das Ereignis PropertyChanged.
