Posts mit dem Label Download werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Download werden angezeigt. Alle Posts anzeigen

Montag, 29. März 2010

Lightweight and free XAML Editor

Von Robby Ingebretsen gibt es einen kostenlosen und sehr schönen XAML-Editor Kaxaml, um seine XAML-Dateien auch ohne Expression Blend nicht im Hardcore-Modus editieren zu müssen.

Silverlight: Custom Effects with DirectX HLSL

Um eine Silverlight Applikation aufzupeppen kann man neben den beiden bereits vorhandenen Effekten BlurEffect (Verwischen) und DropShadowEffect (Schatten) auch noch Custom Effects einsetzen.

Da Silverlight selbstdefinierte Effekte unterstützt, welche mit der High Level Shading Language (HLSL) erstellt wurden, kann man das nachfolgend genannte Shazzam-Tool nutzen, um solche Effekte zu kreieren. Die High Level Shading Language wurde mit DirectX 8 eingeführt und ist eine Sprache zur Definition von Shading-Effekten.

Um Effekte selbst zu definieren, wird die DirectX-SDK und Walt Ritschers’s Shazzam Shader Editing Tool (WPF ClickOnce-Anwendung) benötigt:

Beispiel Emboss-Effekt

Folgendes Beispiel zeigt den vordefinierten Emboss-Effekt aus dem Shazzam-Tool:

image

Das Shazzam-Tool kann dazu verwendet werden, Effekte zu kompilieren (aus .fx shader wird eine .rs-Datei) und die dazugehörigen Klassen zu erzeugen. Das Shazzam-Tool verfügt über sehr schöne bereits vordefinierte Effekte (Embossed, Bloom, InvertColor, Monochrome, ContrastAdjust, usw.). Wichtig ist, das man die Build-Action der zum Visual Studio Projekt hinzugefügten rs-Datei auf “Resource” stellt. Weil Shazzam uns WPF-Code liefert, müssen noch ein paar Änderungen von Hand vorgenommen werden (siehe Was muss man tun? unten).

Das Shazzam-Tool generiert zur Nutzung des Effekts den nachfolgenden Code (C# und Visual Basic):

Referenziert wird hierbei die kompilierte DirectX-Shader-Datei Embossed.ps.

   1: namespace Ch9UsingGraphicsAndVisuals.Effects
   2: {
   3:    using System.Windows;
   4:    using System.Windows.Media;
   5:    using System.Windows.Media.Effects;
   6:    using System;
   7:  
   8:    public class EmbossedEffect : ShaderEffect
   9:    {
  10:       public static DependencyProperty InputProperty = ShaderEffect.RegisterPixelShaderSamplerProperty("Input", typeof(EmbossedEffect), 0);
  11:       public static DependencyProperty AmountProperty = DependencyProperty.Register("Amount", typeof(double), typeof(EmbossedEffect), new System.Windows.PropertyMetadata(new double(), PixelShaderConstantCallback(0)));
  12:       public static DependencyProperty WidthProperty = DependencyProperty.Register("Width", typeof(double), typeof(EmbossedEffect), new System.Windows.PropertyMetadata(new double(), PixelShaderConstantCallback(1)));
  13:       public EmbossedEffect()
  14:       {
  15:          Uri u = new Uri(@"/Ch9UsingGraphicsAndVisuals;component/Shaders/Embossed.ps", UriKind.Relative);
  16:          PixelShader = new PixelShader() { UriSource = u };
  17:          this.UpdateShaderValue(InputProperty);
  18:          this.UpdateShaderValue(AmountProperty);
  19:          this.UpdateShaderValue(WidthProperty);
  20:       }
  21:       public virtual System.Windows.Media.Brush Input
  22:       {
  23:          get
  24:          {
  25:             return ((System.Windows.Media.Brush)(GetValue(InputProperty)));
  26:          }
  27:          set
  28:          {
  29:             SetValue(InputProperty, value);
  30:          }
  31:       }
  32:       public virtual double Amount
  33:       {
  34:          get
  35:          {
  36:             return ((double)(GetValue(AmountProperty)));
  37:          }
  38:          set
  39:          {
  40:             SetValue(AmountProperty, value);
  41:          }
  42:       }
  43:       public virtual double Width
  44:       {
  45:          get
  46:          {
  47:             return ((double)(GetValue(WidthProperty)));
  48:          }
  49:          set
  50:          {
  51:             SetValue(WidthProperty, value);
  52:          }
  53:       }
  54:    }
  55: }

Im XAML-Code muss man dann nur noch dem entsprechendem Objekt (jedes Objekt, was von UIElement erbt hat eine Effect-Eigenschaft) die Effect-Eigenschaft zuweisen:

<Image Source="Images/sampleImage.jpg" Stretch="Fill" Width="154" VerticalAlignment="Top" Height="116" HorizontalAlignment="Left" Margin="180,0,0,0">
  <Image.Effect>
     <localEffects:EmbossedEffect x:Name="EmbossedEffect" Width="0.004" Amount="1" />
  </Image.Effect>
/Image>
Was muss man tun?

Hier noch mal die notwendigen Schritte um eigene Effekte mit dem Shazzam-Tool zu integrieren:

  1. Testen und kompilieren des Shaders in Shazzam
  2. Kompilierte .ps-Datei zum Visual Studio-Projekt hinzufügen und Build Action auf Resource setzen
  3. Neue Effekt-Klasse zum Projekt hinzufügen
  4. Den generierten Shazzam-Code in die Klasse einfügen
  5. Namespace anpassen
  6. Refactor->Klassenname umbenennen
  7. Ändern von UIPropertyMetaData in PropertyMetaData
  8. Erzeugen einer Uri, welche die .ps-Datei referenziert (System wird benötigt)
  9. Hinzufügen eines parameterlosen Konstruktors für unsere Effekt-Klasse, der die Pixel-Shader-Eigenschaft initialisiert

Weitere Effekte sind in der Open Source Shader Bibliothek von Codeplex zu finden.

Freitag, 19. März 2010

Chart Control in VS 2008 and VS 2010

Wer kennt nicht die tägliche Pein mit dem Umgang von vernünftigen Charts in Webseiten - wir plagen uns dann oft mit behelfsmäßigen Konstrukten, wie Integration von Reports mit Microsoft Reporting Services oder kaufen zusätzliche Komponenten, wie z.B. die wirklichen guten Komponenten von DevExpress. Doch jetzt hat Microsoft hier eine Lösung die in .NET 4 integriert ist und man auch für .NET 3.5 mit VS 2008 separat installieren kann.

Review:
Das Microsoft Chart Control ist wirklich eine sehr gelungen Sache. Auf den ersten Blick vermisst man nichts was das Entwicklerherz begehrt. Man kann das Control sowohl statisch als auch dynamisch mit Daten von unterschiedlichen Quellen (DB, Excel, CSV-Datei, usw.) versorgen. Das Control unterstützt AJAX, so das man in Zusammenhang mit dem Click-Event des Controls schöne Master-Detail-Lösungen bauen oder Realtime-Charts implementieren kann. Das Erscheinungsbild des Controls ist in jeder Hinsicht über Attribute oder Code-Behind änderbar, was z.B. eine Schwäche der Charts bei den Reporting Services ist.

Näheres kann man hier finden: Built-in Charting Controls (VS 2010 and .NET 4 Series) - ScottGu's Blog

Direkter Download des Controls für VS 2008 und .NET 3.5: Microsoft Chart Control for .NET Framework

Beispielhafte Definition des Controls:

<asp:Chart ID="Chart1" runat="server" BackColor="#D3DFF0" Palette="BrightPastel"
     ImageType="Png" ImageUrl="~/TempImages/ChartPic_#SEQ(300,3)" Width="412px" Height="296px"
     borderlinestyle="Solid" backgradientendcolor="White" backgradienttype="TopBottom"
     BorderlineWidth="2" BorderlineColor="26, 59, 105" DataSourceID="MasterSource"
     OnClick="Chart1_Click">
     <Titles>
         <asp:Title ShadowColor="32, 0, 0, 0" Font="Trebuchet MS, 14.25pt, style=Bold" ShadowOffset="3"
             Text="Regional Sales" Alignment="TopLeft" ForeColor="26, 59, 105">
         </asp:Title>
     </Titles>
     <Legends>
         <asp:Legend Enabled="False" Name="Default" BackColor="Transparent" Font="Trebuchet MS, 8.25pt, style=Bold">
             <Position Y="21" Height="22" Width="18" X="73"></Position>
         </asp:Legend>
     </Legends>
     <BorderSkin SkinStyle="Emboss"></BorderSkin>
     <Series>
         <asp:Series Name="Sales" BorderColor="180, 26, 59, 105" XValueMember="RegionName"
             YValueMembers="SumOfSales">
         </asp:Series>
     </Series>
     <ChartAreas>
         <asp:ChartArea Name="Default" BorderColor="64, 64, 64, 64" BorderDashStyle="Solid"
             BackSecondaryColor="White" BackColor="64, 165, 191, 228" ShadowColor="Transparent"
             BackGradientStyle="TopBottom">
             <AxisY LineColor="64, 64, 64, 64" IsLabelAutoFit="False">
                 <LabelStyle Font="Trebuchet MS, 8.25pt, style=Bold"></LabelStyle>
                 <MajorGrid LineColor="64, 64, 64, 64"></MajorGrid>
             </AxisY>
             <AxisX LineColor="64, 64, 64, 64" IsLabelAutoFit="False">
                 <LabelStyle Font="Trebuchet MS, 8.25pt, style=Bold"></LabelStyle>
                 <MajorGrid LineColor="64, 64, 64, 64"></MajorGrid>
             </AxisX>
         </asp:ChartArea>
     </ChartAreas>
 </asp:Chart>

Einfaches DataBinding:

   1: // Initializes a new instance of the DataView class
   2: DataView firstView = new DataView(custDS.Tables[0]);
   3:  
   4: // since the DataView implements and IEnumerable, pass the reader directly into
   5: // the DataBind method with the name of the Columns selected in the query    
   6: Chart1.Series["Default"].Points.DataBindXY(firstView, "Name",firstView, "Sales");

Beispiele:

image

image

image

image

Donnerstag, 18. März 2010

Internet Explorer 9 Preview

Microsoft hat am 16.03.2010 auf der MIX10 in Las Vegas den Internet Explorer 9 als Preview präsentiert. Hier wurden die (geplanten) Highlights der neuen Version vorgestellt:

  • Hardwarebeschleunigung
  • Eine neue JavaScript-Engine
  • Standards: HTML5, CSS3, DOM, SVG

Microsoft liefert seiner der Webseite http://ietestdrive.com neben einer Preview-Version auch diverse Testszenarien für diese Standards mit. Ausprobieren und einen Browser-Vergleich lohnt sich.

Dienstag, 16. März 2010

Final release of ASP.NET MVC 2

Der endgültige Release von ASP.NET MVC 2 ist jetzt für VS 2008/Visual Web Developer 2008 Express mit ASP.NET 3.5 verfügbar. ASP.NET MVC 2 kann mit folgenden Links installiert werden:

Die endgültige Version von VS 2010 wird ASP.NET MVC 2 übrigens schon integriert haben.

Mehr Informationen zu ASP.NET MVC 2 sind über ASP.NET MVC 2 Released - ScottGu's Blog verfügbar.

Hinweis: Zur Installation müssen alte Vorabversionen von ASP.NET MVC 2 zunächst deinstalliert werden.

Montag, 22. Februar 2010

Microsofts Concurrency Coordination Runtime (CCR) - Asynchron und doch zusammen

Wenn man mit asynchronen Tasks arbeitet, steht man oft vor dem Problem, das man diese zwar asynchron aufrufen möchte, aber dennoch im Haupttask auf das Ergebnis der losgelaufenen Prozesse warten möchte.

Einen Ansatz, wie dies mit WCF-Mitteln zu lösen ist, liefern uns in der Dotnetpro 3/2010 die Autoren Tobias Richling et al. in folgendem Artikel. Einen alternativen Ansatz unter Verwendung des Kommunikationsframework Xcoordination Application Space zeigt uns Ralf Westphal in seinem Beitrag One Man Think Tank Gedanken: Asynchronizität. Das Xcoordination Application Space (AppSpace)-Framwork ist eine Open Source Komponente, die bei CodePlex liegt und die Verteilung von Anwendungen erlaubt, die mit Microsofts Concurrency Coordination Runtime (CCR) arbeiten.

Ein einfaches Beispiel für einen Worker-Prozess (in mehreren Threads) sieht dann so aus:

   1: using System;
   2: using System.Threading;
   3: using Microsoft.Ccr.Core;
   4: using XcoAppSpaces.Core;
   5:  
   6: namespace MainDemo
   7: {
   8:     class Demo01SimpleWorker
   9:     {
  10:         public static void Main()
  11:         {
  12:             Console.WriteLine("Xco Application Space - Simple Worker Demo / Running on thread {0} / [Enter] to finish", Thread.CurrentThread.GetHashCode());
  13:  
  14:             using (XcoAppSpace space = new XcoAppSpace())
  15:             {
  16:                 // Start a worker locally. Using the call the worker is registered in the AppSpace instance
  17:                 // and listed as active. It´s now ready to received messages through its contract instance.
  18:                 // Workers are singletons.
  19:                 space.RunWorker<PWorker, MyWorker>();
  20:  
  21:                 PWorker w = space.Resolve<PWorker>();
  22:                 w.Post(1);
  23:                 w.Post("hello");
  24:                 w.Post(2);
  25:                 w.Post("world!");
  26:  
  27:                 // Without stopping here the process would terminate before the work
  28:                 // in the background has been finished.
  29:                 Console.ReadLine();
  30:             }
  31:  
  32:             Console.ForegroundColor = ConsoleColor.Green;
  33:             Console.WriteLine("Done! Some output has been generated.");
  34:         }
  35:  
  36:  
  37:         internal class PWorker : PortSet<int, string>{}
  38:  
  39:         // Workers need to implement a CCR Port or PortSet as its contract
  40:         internal class MyWorker : PWorker
  41:         {
  42:             // Mark methods to process contract messages with an Xco App Space attribute
  43:             // to have them automatically wired to a contract port.
  44:             [XcoConcurrent]
  45:             void ProcessInt(int msg)
  46:             {
  47:                 Console.WriteLine("  Received int {0} on thread {1}", msg, Thread.CurrentThread.GetHashCode());
  48:             }
  49:  
  50:             [XcoConcurrent]
  51:             void ProcessString(string msg)
  52:             {
  53:                 Console.WriteLine("  Received string '{0}' on thread {1}", msg, Thread.CurrentThread.GetHashCode());
  54:             }
  55:         }
  56:     }
  57: }