Blog Archives
Singleton Pattern
I did never really care about programming patterns. I had to come up with ideas when I needed them. And back in the Commodore 64 ages, when I wrote my first “Hello World” program in Basic, there was no book about patterns anyway.
When you only allow one object instance, that is called Singleton.
Have you ever come across Remoting? You send a request to a server. There is a choice between Singleton and SingleCall. It basically means that you:
- Always use the same object or
- create a new object for each request.
Let’s say you order 4 pints of beer using your tablet PC rather than calling the sexy, blond, and 18-year-old waitress. You obviously want 4 pints at once. Therefore the correct choice would be SingleCall; 4 distinct objects. The geeky waitress reacts. She responds via her high-tech cash register: “Who are you?”. She could ask that 10 times and unless you get upset, you would always give the same answer. Any good programmer realizes that this would only require one object instance – a Singleton.
There are several ways to do this. The conceptual idea is pretty easy. (Wikipedia has some more details.) In this post I am only giving you my favourite pattern, which should always work. You don’t need more unless you want to show off with some cheap stuff.
Example:
Remove the sealed keyword in case you need to make the class inheritable.
Notice the double-check if (_Instance == null) ...
The reason is:
- The first check avoids entering the lock in 99.9999% of the calls. You save precious processor time.
- The second check avoids an unlikely multithreading problem. A thread A could enter the lock and not finish before a thread B arrives. B has to wait in front of the lock. A exits the lock, now B enters the lock. Without the second check, B would now create a new instance. And this is, what we are trying to avoid.
using System;
namespace Singleton {
public sealed class JustOne {
private static readonly object _Lock = new object();
private static JustOne _Instance = null;
private JustOne() { }
public static JustOne Instance {
get {
if (_Instance == null) {
lock (_Lock) {
if (_Instance == null) _Instance = new JustOne();
}
}
return _Instance;
}
} //
public new string GetHashCode() { return base.GetHashCode().ToString(); }
} // class
class Program {
static void Main(string[] args) {
JustOne A = JustOne.Instance;
JustOne B = JustOne.Instance;
Console.WriteLine("HashCode of object A: " + A.GetHashCode());
Console.WriteLine("HashCode of object B: " + B.GetHashCode());
Console.ReadLine();
} // main
} // class
} // namespace
Facade Pattern
Don’t shoot the messenger!
This is something that you are doing all the time. We just name it now. The Facade Pattern is a structural programming design pattern. To explain it in a nutshell:
A class contains many references to objects, which are invisible to the client. The client has a reduced command set to keep things simple.
The class receives the simple command and takes care about the real complexity behind the facade, which is presented to the client. Think of a cash dispenser. All you have to know is a few buttons. The legal structure, the buildings, the accounting, the risk etc. … all is invisible to the client, who only cares about getting cash at this very moment.
namespace FacadePattern {
internal class Burger {
public void Prepare() { }
public void WarmUp() { }
public void Wrap() { }
} // class
internal class Fries {
public void Fry() { }
public void KeepWarm() { }
} // class
internal class Drink {
public enum eDrink { Coke, SevenUp, Orange, Apple, Milk, Tea, Coffee }
public bool IsSugarFree { set; get; }
public bool IsHot { set; get; }
public void Fill(eDrink xDrink) { }
} // class
internal class Extras {
public void AddSalt() { }
public void AddKetchup() { }
public void AddMayo() { }
public void AddNapkin() { }
} // class
public class MealFacade {
private Burger _Burger = new Burger();
private Fries _Fries = new Fries();
private Drink _Drink = new Drink();
private Extras _Extras = new Extras();
public void MakeClientHappy() {
_Drink.IsHot = false;
_Drink.IsSugarFree = true;
_Drink.Fill(Drink.eDrink.Coke);
_Fries.Fry();
_Burger.Prepare();
_Burger.Wrap();
_Extras.AddKetchup();
_Extras.AddSalt();
_Extras.AddNapkin();
} //
} // class
class Program {
static void Main(string[] args) {
MealFacade lBurgerMeal = new MealFacade();
lBurgerMeal.MakeClientHappy();
} // main
} // class
} // namespace
Prototype Pattern
Sometimes the creation of new objects is time and resource intensive. You could create a thousand objects during the program initialization and park them on a queue. The object would then be ready when needed. And looking at the Garbage Collection process in more detail, you may notice that the Generation has probably changed by then. Your object requires less processor time the older it becomes.
But this is not the topic today. It just has a similar idea. We are talking about time and/or resource intensive object creation.
The Prototype Pattern is used for cloning objects. Cloning can be substantially faster than initializing objects from scratch. Let’s say object A did load a lot of data from a file. You don’t have to do the same for object B. Simply copy object A and amend some fields.
Here is the pattern:
public interface IChocolateBar {
IChocolateBar Clone();
} // interface
public class MintChocolateBar : IChocolateBar {
public readonly int ObjectNumber;
public MintChocolateBar(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public IChocolateBar Clone() { return MemberwiseClone() as MintChocolateBar; }
} // class
public class DarkChocolateBar : IChocolateBar {
public readonly int ObjectNumber;
public DarkChocolateBar(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public IChocolateBar Clone() { return MemberwiseClone() as DarkChocolateBar; }
} // class
public class CloneFactory {
public IChocolateBar get(IChocolateBar xChocolateBar) { return xChocolateBar.Clone(); }
} // class
The pattern is not really satisfying. Is there something better? C# offers the ICloneable interface.
public class Shortcut : ICloneable {
public readonly int ObjectNumber;
public Shortcut(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public object Clone() { return MemberwiseClone(); }
} // class
The problem with this interface is the missing generic type. In fact the use is obsolete and Microsoft does not recommend it anymore. We therefore build our own implementation.
public class Shortcut2 {
public readonly int ObjectNumber;
public Shortcut2(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public Shortcut2 ShallowCopy() { return MemberwiseClone() as Shortcut2; }
} // class
Using an interface like
interface IShallowCopy<T> {
T IShallowCopy();
} // interface
public class Shortcut3<T> : IShallowCopy<T> {
public readonly int ObjectNumber;
public Shortcut3(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public T ShallowCopy() { return MemberwiseClone() as T; }
} // class
is nonsense. You cannot compile and instantiate this.
What else could we do? A static clone method quickly leads us back to a factory similar type. Hence we end up with something that we were having at the very beginning today. Just keep your solutions generic and you should be fine with this pattern.
MemberwiseClone()
We were using MemberwiseClone() to keep the example source code simple. The following is important to know:
MemberwiseClone() is a shallow copy. If a field of the copied object is a reference type, the reference is copied but the referred object is not; therefore, the original object and its clone refer to the same object.
To avoid the same references in the clone, you have to write your own Deep Copy or Lazy Copy. Your clone method must clone the object and objects inside the object.
A practical example:
Stock exchange orders need to be sent with a minimal delay. The fight for nanoseconds is tremendous. Companies even shorten the physical server cables to the exchanges in order to increase speed. One foot in length equals roughly one nanosecond these days.
The object creation for orders takes too long in the proprietary business. It is meaningful to generate orders before any decision is made. The next order sits in a queue of clones. When the machine decides to trade, then the order is taken from that queue and a few fields are populated/overridden. These are eg. trade size and price. There is no memory allocation at this late stage. As said, each nanosecond counts.
Full source code
Notice that
Console.WriteLine("ObjectNumber = " + lMintClone.ObjectNumber);
prints the same number as the original object. There are two objects at two locations in the RAM. Therefore the HashCode is different. Still the field content is the same.
using System;
namespace PrototypePattern {
public interface IChocolateBar {
IChocolateBar Clone();
} // interface
public class MintChocolateBar : IChocolateBar {
public readonly int ObjectNumber;
public MintChocolateBar(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public IChocolateBar Clone() { return MemberwiseClone() as MintChocolateBar; }
} // class
public class DarkChocolateBar : IChocolateBar {
public readonly int ObjectNumber;
public DarkChocolateBar(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public IChocolateBar Clone() { return MemberwiseClone() as DarkChocolateBar; }
} // class
public class CloneFactory {
public IChocolateBar get(IChocolateBar xChocolateBar) { return xChocolateBar.Clone(); }
} // class
// IClonable is non-generic
public class Shortcut : ICloneable {
public readonly int ObjectNumber;
public Shortcut(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public object Clone() { return MemberwiseClone(); }
} // class
public class Shortcut2 {
public readonly int ObjectNumber;
public Shortcut2(int xObjectNumber) { ObjectNumber = xObjectNumber; }
public Shortcut2 ShallowCopy() { return MemberwiseClone() as Shortcut2; }
} // class
class Program {
static void Main(string[] args) {
CloneFactory lCloneFactory = new CloneFactory();
MintChocolateBar lMint = new MintChocolateBar(1);
MintChocolateBar lMintClone = lCloneFactory.get(lMint) as MintChocolateBar;
Console.WriteLine("Original object: ");
Console.WriteLine("HashCode = " + lMint.GetHashCode());
Console.WriteLine("ObjectNumber = " + lMint.ObjectNumber);
Console.WriteLine();
Console.WriteLine("Clone: ");
Console.WriteLine("HashCode = " + lMintClone.GetHashCode());
Console.WriteLine("ObjectNumber = " + lMintClone.ObjectNumber); // !!!
Console.WriteLine();
Console.WriteLine("Are the objects the same? " + (lMint == lMintClone));
DarkChocolateBar lDark = new DarkChocolateBar(2);
DarkChocolateBar lDarkClone = lCloneFactory.get(lDark) as DarkChocolateBar;
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Dark chocolate: ");
Console.WriteLine("Are the objects the same? " + (lMint == lMintClone));
// old school
Shortcut lShort = new Shortcut(3);
Shortcut lShortClone = lShort.Clone() as Shortcut;
Console.WriteLine();
Console.WriteLine("ICloneable: ");
Console.WriteLine("Are the objects the same? " + (lShort == lShortClone));
Console.ReadLine();
} //
} // class
} // namespace
example output:
Original object:
HashCode = 62125865
ObjectNumber = 1Clone:
HashCode = 44200505
ObjectNumber = 1Are the objects the same? False
Dark chocolate:
Are the objects the same? FalseICloneable:
Are the objects the same? False
Builder Pattern
Who does not know the StringBuilder in namespace System.Text?
The purpose of the StringBuilder is to construct a string much faster than using the operator overload “+”. Strings are immutable. Each time you use the overloaded operator, a new object is created. That slows down the creation of the final object. Here is a quick benchmark:
using System;
using System.Diagnostics;
using System.Text;
namespace demo {
class Program {
static void Main(string[] args) {
Stopwatch lStopwatch = new Stopwatch();
lStopwatch.Start();
string s = "";
for (int i = 0; i < 100000; i++) s += "x";
lStopwatch.Stop();
Console.WriteLine("Operator, elapsed ms: " + lStopwatch.ElapsedMilliseconds);
StringBuilder lStringBuilder = new StringBuilder();
lStopwatch.Restart();
for (int i = 0; i < 100000; i++) lStringBuilder.Append("x");
lStopwatch.Stop();
Console.WriteLine("StringBuilder, elapsed ms: " + lStopwatch.ElapsedMilliseconds);
Console.ReadLine();
} //
} // class
} // namespace
example output:
Operator, elapsed ms: 3029
StringBuilder, elapsed ms: 1
The StringBuilder supports method chaining. You can shorten your source code and write:
string s = new StringBuilder()
.Append("a")
.Append("b")
.Append("c")
.Append("d")
.ToString();
instead of
StringBuilder lStringBuilder = new StringBuilder();
lStringBuilder.Append("a");
lStringBuilder.Append("b");
lStringBuilder.Append("c");
lStringBuilder.Append("d");
string s = lStringBuilder.ToString();
In general the purpose of a Builder is to separate complex object construction from its representation.
We leave the idea of strings behind and build something entirely different. This time it is not about speed, it is more about avoiding thousands of parameters in constructors and making complexity look a little bit easier. Two weeks ago I was using BMW AG to give an example for an Abstract Factory. Let’s stay loyal to cars and build classes for the production assembly.
using System;
namespace demo {
[Flags]
public enum eRadio { GPS = 1, MP3 = 2, Screen = 4, Phone = 8 }
public enum eColor { NotSet = 0, Silver, Red, Blue, White, Black }
class Program {
public class Car {
public readonly eRadio Radio;
public readonly eColor Color;
public readonly double Displacement;
public readonly int Doors;
public readonly bool Hatchback;
public readonly bool LeatherSeats;
internal Car(eRadio xRadio, eColor xColor, double xDisplacement, int xDoors, bool xHatchback, bool xLeatherSeats) {
Radio = xRadio;
Color = xColor;
Displacement = xDisplacement;
Doors = xDoors;
Hatchback = xHatchback;
LeatherSeats = xLeatherSeats;
} // constructor
} // class
public class CarBuilder {
private eRadio _Radio = 0;
private eColor _Color = eColor.NotSet;
private double _Displacement = 0.0;
private uint _Doors = 1;
private bool? _Hatchback = null;
private bool? _LeatherSeats = null;
internal CarBuilder SetColor(eColor xValue) { _Color = xValue; return this; }
internal CarBuilder SetDisplacement(double xValue) { _Displacement = xValue; return this; }
internal CarBuilder SetDoors(uint xValue) { _Doors = xValue; return this; }
internal CarBuilder SetHatchback(bool xValue) { _Hatchback = xValue; return this; }
internal CarBuilder SetRadio(eRadio xValue) { _Radio = xValue; return this; }
internal CarBuilder SetLeatherSeats(bool xValue) { _LeatherSeats = xValue; return this; }
internal Car Create() {
if (_Hatchback == null) throw new Exception("Hatchback not set");
if (_LeatherSeats == null) throw new Exception("LeatherSeats not set");
if (_Doors < 1 || _Doors > 6) throw new Exception("number of Doors invalid");
// ... etc.
return new Car(_Radio, _Color, _Displacement, (int)_Doors, (bool)_Hatchback, (bool)_LeatherSeats);
}
} // class
static void Main(string[] args) {
Car lCar = new CarBuilder()
.SetColor(eColor.Silver)
.SetDisplacement(2.2)
.SetDoors(5)
.SetHatchback(true)
.SetRadio(eRadio.GPS | eRadio.MP3 | eRadio.Screen)
.SetLeatherSeats(true)
.Create();
Console.ReadLine();
} // main
} // class
} // namespace
Adapter Pattern
Once again it sounds more difficult than it actually is.
What is an Adapter?
An Adapter sits in between two objects that cannot be changed and cannot talk to each other. It is like the American and British power socket:
- The socket shape and voltage are different.
- You cannot change the situation. The source and the target are static.
- An adapter can connect the two systems.
Adapters can also connect to several source or target objects. Let’s imagine a database is split in two. An Adapter could connect to the two separate databases and return the result as if it was just one. Using several source objects is uncommon. It does make sense, when events from two or more sources need to occur before the access to the target object can take place.
I’d say that the Adapter pattern is not more than a workaround, it is a compromise to avoid other problems. There is a difference between chewing gum and glue. Both can hold pieces together … somehow.
Imagine a British datacenter with 1000 (US->UK) power socket adapters. It would work, but don’t wonder, when someone stumbles over a adapter and disconnects something important.
(The WPF value converter is similar, not the same though. The converter eg. accepts a string and returns a double.)
Here is a short example:
namespace demo {
public interface IPrinterDriver {
void Print(string xText);
} // interface
// Client
public class PrinterDriver : IPrinterDriver {
private readonly IPrinterDriver _Driver;
public PrinterDriver(IPrinterDriver xDriver) { _Driver = xDriver; }
public void Print(string xText) { _Driver.Print(xText); }
} // class
// Adaptee
public class Windows3_1_MatrixPrinterDriver {
public void Init(string xCommandSequence) { ... }
public void ParkPrintHead() { ... }
public void Print(string xText) { ... }
} // class
// Adapter
public class Win8_to_Win31_PrinterDriverAdapter : IPrinterDriver {
private readonly Windows3_1_MatrixPrinterDriver _Driver = new Windows3_1_MatrixPrinterDriver();
public void Print(string xText) {
_Driver.Init("§50asabpwebts.dae§");
_Driver.Print(xText);
_Driver.ParkPrintHead();
} //
} // class
class Program {
static void Main(string[] args) {
Win8_to_Win31_PrinterDriverAdapter lAdapter = new Win8_to_Win31_PrinterDriverAdapter();
PrinterDriver lDriver = new PrinterDriver(lAdapter);
lDriver.Print("Hello World!");
} //
} // class
} // namespace
In many examples the adapter inherits the Adaptee AND the Interface, which would then look like this:
public class Win8_to_Win31_PrinterDriverAdapter : IPrinterDriver, Windows3_1_MatrixPrinterDriver { ... }
I disagree with such approach and rather use create a private readonly field instead. It is easier to avoid naming conflicts then.
Abstract Factory Pattern
There are many definitions on the internet of what the factory pattern would/should be. It is important to comply with your professor while you study at a university. Besides that programming is an art. It has nothing to do with naming conventions. Mona Lisa could be named Paul, you see. Only posh people care about technique naming. But if you paint a picture yourself, you don’t care about any technique naming convention at all; you only care about your results. And if people like it, then you are successful. It is the same with programming.
The Factory Method Pattern usually refers to a class that creates just one type of object.
The Abstract Factory Pattern usually refers to a class that can create various types of objects, which have something in common.
Besides that we have a lot of gibberish about some 10 and more years old pattern.
I could add a lot of code here, but it should suffice to just get the idea of it. Have a look at the above picture. An abstract class/interface is used as the base class for country specific factories. These factories create the objects.
The Z4 Model is built in Germany and China (just for demonstration purposes). Basically they are the same besides the difference between the Chinese and German regulations.
Now, translate that to your own business case. You may need a Factory that creates code for your Unix, Mac, and Windows system. On top of that you may have to create two distinct objects for your test and prod environment.
Factory pattern
Life was so easy. Why do we have to make it worse now and implement a so-called “Factory”?
Dependency Injection is about using abstract classes and interfaces to avoid concrete classes. Therefore the creation of a concrete class like “new Ferrari()” violates the idea of flexibility and dependency injection. The Factory Pattern allows us to instantiate concrete classes while depending only on abstract classes/interfaces. The development process becomes much easier in an environment where concrete classes are changing frequently.
using System;
namespace demo {
public abstract class Car { public string Name { get; protected set; } }
public class Ferrari : Car { public Ferrari() { Name = "Red Speeder"; } }
public class VW : Car { public VW() { Name = "German Classic"; } }
public class Fiat : Car { public Fiat() { Name = "White Something"; } }
public interface ICarFactory {
Car GetObjectExpensive();
Car GetObjectCheap();
} // interface
public class CarFactory : ICarFactory {
public Car GetObjectExpensive() { return new Ferrari(); }
public Car GetObjectCheap() { return new Fiat(); }
} // class
public class DependentClass {
public readonly Car car = new Ferrari();
} // class
public class IndependentClass {
public readonly Car car;
public IndependentClass(Car xCar) {
car = xCar;
} // constructor
} // class
class Program {
static void Main(string[] args) {
DependentClass d = new DependentClass();
CarFactory lCarFactory = new CarFactory();
IndependentClass i = new IndependentClass(lCarFactory.GetObjectExpensive());
Console.WriteLine(i.car.Name); // Red Speeder
Console.ReadLine();
} // main
} // class
} // namespace
The code, which was dependent on the concrete class Ferrari, now only depends on the base class Car. You can easily inject any other car like VW or Fiat into your class. There is no need to search for all “new Ferrari()” commands in your code in case you need to change the type of car. It is all in one place. The dependency on the concrete class is gone.
We can increase the flexibility even further and use:
public interface ICarFactory {
Car GetObject(string xType);
} // interface
public class CarFactory : ICarFactory {
public Car GetObject(string xType) {
switch (xType) {
case "Expensive": return new Ferrari();
case "Average": return new VW();
case "Cheap": return new Fiat();
default: return null;
}
}
} // class
...
IndependentClass i = new IndependentClass(lCarFactory.GetObject("Expensive"));
...
The string can be replaced by an enum.
public enum eCar { Expensive, Average, Cheap };
public interface ICarFactory {
Car GetObject(eCar xType);
} // interface
public class CarFactory : ICarFactory {
public Car GetObject(eCar xType) {
switch (xType) {
case eCar.Expensive: return new Ferrari();
case eCar.Average: return new VW();
case eCar.Cheap: return new Fiat();
default: return null;
}
} //
} // class
public class IndependentClass1 {
public readonly Car car;
public IndependentClass1(Car xCar) {
car = xCar;
} // constructor
} // class
public class IndependentClass2 {
public readonly Car car;
public IndependentClass2() {
CarFactory lCarFactory = new CarFactory();
car = lCarFactory.GetObject(eCar.Expensive);
} // constructor
} // class
...
class Program {
static void Main(string[] args) {
DependentClass d = new DependentClass();
CarFactory lCarFactory = new CarFactory();
IndependentClass1 i1 = new IndependentClass1(lCarFactory.GetObject(eCar.Expensive));
IndependentClass2 i2 = new IndependentClass2();
Console.WriteLine(i2.car.Name); // Red Speeder
Console.ReadLine();
} // main
} // class
The Factory Pattern should only be used, when the need for it becomes great enough. Let’s say you are doing unit testing and you need to spoof the creator of an object. A Factory can be quite helpful then.
Factories add complexity to your code, so do not use them by default. They are conforming with Dependency Injection. Nevertheless, check the price you are willing to pay for independence.
Summary:
- A factory method returns one of several possible classes that share an interface/abstract class/(parent class).
- The class is chosen at runtime.
- Before: Car c = new Ferrari(); After: Car c = lCarFactory.GetObject(eCar.Expensive);
- Don’t use the Factory Pattern by default.
Cascade pattern / Method chaining
Today, I am going to explain a simple programming pattern step by step.
Often the cascade pattern can be found in connection with consecutive data manipulation. It has many names. In C# I would put it in the same chapter as Extension Methods.
But let us start at the very beginning. Genesis 🙂
This is a simple integer calculation.
int r0 = 5;
r0 = ((((r0 + 2) * 4) - 8) / 2) + 1;
Console.WriteLine("Result is " + r0); // 11
We could break it down into many separate calculation steps …
int r1 = 5;
r1 += 2; r1 *= 4; r1 -= 8; r1 /= 2; r1 += 1;
Console.WriteLine("Result is " + r1); // 11
… and build a class to perform reoccurring calculations.
public class Classic {
static public int add(int a, int b) { return a + b; }
static public int sub(int a, int b) { return a - b; }
static public int mul(int a, int b) { return a * b; }
static public int div(int a, int b) { return a / b; }
} // class
int r2 = 5;
r2 = Classic.add(r2, 2);
r2 = Classic.mul(r2, 4);
r2 = Classic.sub(r2, 8);
r2 = Classic.div(r2, 2);
r2 = Classic.add(r2, 1);
Console.WriteLine("Result is " + r2); // 11
Well, this is nice. But the code is clumsy. We could overload operators. Anyhow, this is not the way I would like to go today. What about a memory variable in form of a property called “Result”.
public class Cascade1 {
public int Result { get; private set; }
public Cascade1(int x) { Result = x; }
public Cascade1 add(int x) { Result += x; return this; }
public Cascade1 sub(int x) { Result -= x; return this; }
public Cascade1 mul(int x) { Result *= x; return this; }
public Cascade1 div(int x) { Result /= x; return this; }
} // class
int c1 = new Cascade1(5)
.add(2)
.mul(4)
.sub(8)
.div(2)
.add(1)
.Result;
Console.WriteLine("Result is " + c1); // 11
This looks much better, doesn’t it?
We replace the integers by a simple class, which only has one public field called “Age”.
public class Data {
public int Age;
} // class
We add IENumberable as parameter. Now, the program looks neat and more flexible.
public class Cascade2 {
public static void add(IEnumerable<Data> xIENumberable, int xValue) { foreach (Data x in xIENumberable) x.Age += xValue; }
public static void sub(IEnumerable<Data> xIENumberable, int xValue) { foreach (Data x in xIENumberable) x.Age -= xValue; }
public static void mul(IEnumerable<Data> xIENumberable, int xValue) { foreach (Data x in xIENumberable) x.Age *= xValue; }
public static void div(IEnumerable<Data> xIENumberable, int xValue) { foreach (Data x in xIENumberable) x.Age /= xValue; }
} // class
List<Data> lList = new List<Data>(); for (int i = 0; i < 10; i++) lList.Add(new Data() { Age = i });
Cascade2.add(lList, 2);
Cascade2.mul(lList, 4);
Cascade2.sub(lList, 8);
Cascade2.div(lList, 2);
Cascade2.add(lList, 1);
Console.Write("Array result is "); lList.ForEach(x => Console.Write(x.Age + " "));
But once again we face too many parameters. Should we add a memory field? No, C# offers Extension Methods. This is the way to go!
public static class Cascade3 {
public static IEnumerable<Data> add(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age += xValue;
return xIENumberable;
} //
public static IEnumerable<Data> sub(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age -= xValue;
return xIENumberable;
} //
public static IEnumerable<Data> mul(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age *= xValue;
return xIENumberable;
} //
public static IEnumerable<Data> div(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age /= xValue;
return xIENumberable;
} //
} // class
List<Data> lList = new List<Data>(); for (int i = 0; i < 10; i++) lList.Add(new Data() { Age = i });
lList.add(2)
.mul(4)
.sub(8)
.div(2)
.add(1);
Console.Write("Array result is "); lList.ForEach(x => Console.Write(x.Age + " "));
Each List object can now use the extension methods. In C# you most likely have come across such pattern when using the namespace System.Linq. Adding this namespace automatically enables many methods for lists (IENumerable) and arrays. Here is an example of that namespace. You can chain together methods. Make sure the return parameter points to the same list each time, otherwise the chain is broken. For instance a Sum() would return a number rather an IENumerable, thus breaking the chain.
List<Data> lList = new List<Data>(); for (int i = 0; i < 10; i++) lList.Add(new Data() { Age = i });
// using System.Linq;
List<Data> lResult = lList.Where(x => x.Age % 2 == 0).Take(10).ToList();
Console.Write("Array result is "); lResult.ForEach(x => Console.Write(x.Age + " "));
And here is the entire source code in one piece.
using System;
using System.Collections.Generic;
using System.Linq;
namespace CascadePattern {
public class Data {
public int Age;
} // class
public static class Cascade3 {
public static IEnumerable<Data> add(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age += xValue;
return xIENumberable;
} //
public static IEnumerable<Data> sub(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age -= xValue;
return xIENumberable;
} //
public static IEnumerable<Data> mul(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age *= xValue;
return xIENumberable;
} //
public static IEnumerable<Data> div(this IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age /= xValue;
return xIENumberable;
} //
} // class
class Program {
public class Classic {
static public int add(int a, int b) { return a + b; }
static public int sub(int a, int b) { return a - b; }
static public int mul(int a, int b) { return a * b; }
static public int div(int a, int b) { return a / b; }
} // class
public class Cascade1 {
public int Result { get; private set; }
public Cascade1(int x) { Result = x; }
public Cascade1 add(int x) { Result += x; return this; }
public Cascade1 sub(int x) { Result -= x; return this; }
public Cascade1 mul(int x) { Result *= x; return this; }
public Cascade1 div(int x) { Result /= x; return this; }
} // class
public class Cascade2 {
public static void add(IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age += xValue;
} //
public static void sub(IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age -= xValue;
} //
public static void mul(IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age *= xValue;
} //
public static void div(IEnumerable<Data> xIENumberable, int xValue) {
foreach (Data x in xIENumberable) x.Age /= xValue;
} //
} // class
static void Main(string[] args) {
int r0 = 5;
r0 = ((((r0 + 2) * 4) - 8) / 2) + 1;
Console.WriteLine("Result is " + r0); // 11
int r1 = 5;
r1 += 2; r1 *= 4; r1 -= 8; r1 /= 2; r1 += 1;
Console.WriteLine("Result is " + r1); // 11
int r2 = 5;
r2 = Classic.add(r2, 2);
r2 = Classic.mul(r2, 4);
r2 = Classic.sub(r2, 8);
r2 = Classic.div(r2, 2);
r2 = Classic.add(r2, 1);
Console.WriteLine("Result is " + r2); // 11
int c1 = new Cascade1(5)
.add(2)
.mul(4)
.sub(8)
.div(2)
.add(1)
.Result;
Console.WriteLine("Result is " + c1); // 11
List<Data> lList = new List<Data>();
for (int i = 0; i < 10; i++) lList.Add(new Data() { Age = i });
Cascade2.add(lList, 2);
Cascade2.mul(lList, 4);
Cascade2.sub(lList, 8);
Cascade2.div(lList, 2);
Cascade2.add(lList, 1);
Console.Write("Array result is ");
lList.ForEach(x => Console.Write(x.Age + " "));
Console.WriteLine();
lList.Clear();
for (int i = 0; i < 10; i++) lList.Add(new Data() { Age = i });
lList.add(2)
.mul(4)
.sub(8)
.div(2)
.add(1);
Console.Write("Array result is ");
lList.ForEach(x => Console.Write(x.Age + " "));
Console.WriteLine();
// using System.Linq;
lList.Clear();
for (int i = 0; i < 50; i++) lList.Add(new Data() { Age = i });
List<Data> lResult = lList.Where(x => x.Age % 2 == 0).Take(10).ToList();
Console.Write("Array result is ");
lResult.ForEach(x => Console.Write(x.Age + " "));
Console.ReadLine();
} //
} // class
} // namespace
example output:
Result is 11
Result is 11
Result is 11
Result is 11
Array result is 1 3 5 7 9 11 13 15 17 19
Array result is 1 3 5 7 9 11 13 15 17 19
Array result is 0 2 4 6 8 10 12 14 16 18
Routed Events (part 2)
Referring back to Routed Events (to part 1), let’s have a closer look at this part of the example source code:
// bubbling
private void MyMouseUp(object sender, MouseButtonEventArgs e) {
FrameworkElement lElement = sender as FrameworkElement;
string lAppend = Environment.NewLine;
if (sender is Window) lAppend += Environment.NewLine;
Results.Text += e.RoutedEvent.RoutingStrategy.ToString() + ": " + lElement.ToString() + lAppend;
e.Handled = false;
Results.ScrollToEnd();
} //
Suppressing Events
e.Handled allows you to halt the event routing process. Set this boolean to true and the event stops traveling any further. A small change demonstrates the altered behavior:
// bubbling
private void MyMouseUp(object sender, MouseButtonEventArgs e) {
FrameworkElement lElement = sender as FrameworkElement;
string lAppend = Environment.NewLine;
if (sender is Window) lAppend += Environment.NewLine;
Results.Text += e.RoutedEvent.RoutingStrategy.ToString() + ": " + lElement.ToString() + lAppend;
e.Handled = (e.ChangedButton == MouseButton.Right);
Results.ScrollToEnd();
} //
If you use the right MouseButton now, the bubbling routing event process stops. The same applies to the tunneling process when you change the MyPreviewMouseUp() method accordingly.
Raising Suppressed Events
You can avoid the suppression of Routed Events. This cannot be done through XAML. Use the AddHandler() method instead. An overload accepts a boolean for its third parameter. Set this one to true and you will receive events even if the e.Handled flag was set to true.
Let’s slightly change our example source code to:
<Window x:Class="DemoApp.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:app="clr-namespace:DemoApp"
Title="MainWindow" Height="500" Width="630"
Name="MyWindow" PreviewMouseUp="MyPreviewMouseUp">
...
...
public MainWindow() {
InitializeComponent();
List<Data> lItems = new List<Data>() {
new Data() {Name = "Otto", LastName = "Waalkes"},
new Data() {Name = "Heinz", LastName = "Rühmann"},
new Data() {Name = "Michael", LastName = "Herbig"},
new Data() {Name = "Sky", LastName = "du Mont"},
new Data() {Name = "Dieter", LastName = "Hallervorden"},
new Data() {Name = "Diether", LastName = "Krebs"},
new Data() {Name = "Helga", LastName = "Feddersen"},
new Data() {Name = "Herbert", LastName = "Grönemeyer"},
};
MyListView.ItemsSource = lItems;
MyWindow.AddHandler(UIElement.MouseUpEvent, new MouseButtonEventHandler(MyMouseUp), true);
} //
...
Et voilà! The Routed Event gets executed despite the set e.Handled flag.
Attached Events
The Click event is defined in the ButtonBase class. It is a kind of combination of a Button press and release. But how can you use the bubbling behavior on a higher level like eg. a Grid that does not derive from the ButtonBase class? Attached events enable you to add event handlers to arbitrary elements, which do not define or inherit these.
Let’s add a Click event to the window level by adding Button.Click=”MyClick”:
<Window x:Class="DemoApp.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:app="clr-namespace:DemoApp"
Title="MainWindow" Height="500" Width="630"
Name="MyWindow" PreviewMouseUp="MyPreviewMouseUp"
Button.Click="MyClick" >
...
private void MyClick(object sender, RoutedEventArgs e) {
MessageBox.Show("Click received!");
} //
The program does not raise any Click events. We did even override the Click event of our TripleClickButton class. You won’t see a lot. But have a look at the two scroll bars. The scroll bar background (not the scroll bar itself) raises click events. As we are on the window level, we now receive these unexpected events. Indeed, this is a good example. A click of the scroll bar background bubbles through the hierarchy and finally raises the attached Click event on the window level.
Don’t forget to analyse the e.Source of your event parameter. You need to filter out the right Click event.
Style EventSetter
While Property setters are most common in Styles, EventSetters are rarely seen. They can be used for more complex problems. The simple ones should be solved by using Style.Triggers. Let’s say you want to change the color of a TextBlock when entering or leaving the area with the mouse cursor.
...
<Window.Resources>
<Style x:Key="ChangeBackgroundColor" TargetType="TextBlock">
<EventSetter Event="TextBlock.MouseEnter" Handler="ChangeBackgroundColorOnMouseEnter" /> // direct event
<EventSetter Event="TextBlock.MouseLeave" Handler="ChangeBackgroundColorOnMouseLeave" /> // direct event
</Style>
</Window.Resources>
...
<TextBlock Text="LastName: " Grid.Column="2" VerticalAlignment="Center" FontSize="16" Style="{StaticResource ChangeBackgroundColor}"/>
...
private void ChangeBackgroundColorOnMouseEnter(object sender, MouseEventArgs e) { ((TextBlock)sender).Background = Brushes.Red; }
private void ChangeBackgroundColorOnMouseLeave(object sender, MouseEventArgs e) { ((TextBlock)sender).Background = null; }
This example could be simplified. No C# code required:
...
<Window.Resources>
<Style x:Key="ChangeBackgroundColor" TargetType="TextBlock">
<Style.Triggers>
<Trigger Property="TextBlock.IsMouseOver" Value="True">
<Setter Property="TextBlock.Background" Value="Red" />
</Trigger>
</Style.Triggers>
</Style>
</Window.Resources>
...
<TextBlock Text="LastName: " Grid.Column="2" VerticalAlignment="Center" FontSize="16" Style="{StaticResource ChangeBackgroundColor}"/>
...
I see the need for further explanations on Trigger types. I have just added a reminder on my To-Do-List.
But for now a simple list must suffice:
- Trigger: Simplest trigger form. Reacts on DependencyProperty changes and then uses setters to change styles.
- MultiTrigger: Combines multiple Triggers. All conditions must be met.
- DataTrigger: Reacts on changes in bound data.
- MultiDataTrigger: Combines multiple DataTriggers. All conditions must be met.
- EventTrigger: Reacts on events. Used for animations.
In a nutshell: There are three trigger types. They use dependency properties, routed events or data binding.
Routed Events (part 1)
Events notify your code that something has happened. You subscribe to events like you subscribe eg. to a monthly magazine. Let’s say a new magazine comes out. The postal worker delivers it to your mail box. You don’t need to ask for the new magazine to be sent to you each time.
Something similar takes place in WPF. A button is pressed and the program delivers that information to your mail box, which is a callback method.
Links:
Events Part1
Events Part2
Events Part3
The classical event has a standard pattern:
public delegate void dMyDelegate();
public event dMyDelegate MyEvent;
public void addEvent() { MyEvent += Callback; }
public void removeEvent() { MyEvent -= Callback; }
public void CallEvent() {
dMyDelegate d = MyEvent;
if (d == null) return;
d();
} //
void Callback() { Console.WriteLine("Event raised"); }
Or this:
private EventHandler _Handler;
public event EventHandler MyEvent {
add { _Handler += value; }
remove { _Handler -= value; }
} //
...
But what exactly is a “Routed Event”?
Routed Events are used in connection with WPF. They are required for a certain routing concept. In WinForms the callback is sent by the corresponding component (eg. the button). But in WPF event routing allows an event to take place in one element, but be raised by another one. That way you can handle events in the most convenient place.
A Button could be part of a template, which in turn is a part of a ListView. The Button could have an image, an ornated border, a grid and many extras. It does make sense to receive events on the group level sometimes.
We know direct events from WinForms. A mouse click raises an event. But in WPF there are two more types:
- Bubbling Events: They travel up the hierarchy of the visual tree. The click raises an event on the button, then on the grid, then on the window. It also raises events on all objects on the way.
- Tunneling Events: These events travel to the opposite direction. A keyboard entry would start at the window level, then travel through the grid towards the button.
Let’s just delve into a practical example. Run the code and observe what is happening.
<Window x:Class="DemoApp.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="500" Width="630"
MouseUp="MyMouseUp" PreviewMouseUp="MyPreviewMouseUp">
<Grid MouseUp="MyMouseUp" PreviewMouseUp="MyPreviewMouseUp">
<Grid.RowDefinitions>
<RowDefinition Height="300" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<ListView Name="MyListView" Margin="0,0,0,0" Grid.IsSharedSizeScope="True" ScrollViewer.VerticalScrollBarVisibility="Auto" ScrollViewer.CanContentScroll="True" MouseUp="MyMouseUp" PreviewMouseUp="MyPreviewMouseUp" Grid.Row="0">
<ListView.ItemTemplate>
<DataTemplate>
<GroupBox Header="Item" FontSize="10">
<Grid PreviewMouseUp="MyPreviewMouseUp" MouseUp="MyMouseUp">
<Grid.ColumnDefinitions>
<ColumnDefinition />
<ColumnDefinition SharedSizeGroup="A" />
<ColumnDefinition />
<ColumnDefinition SharedSizeGroup="A" />
<ColumnDefinition />
</Grid.ColumnDefinitions>
<TextBlock Text="Name: " Grid.Column="0" VerticalAlignment="Center" FontSize="16" PreviewMouseUp="MyPreviewMouseUp"/>
<TextBlock Text="{Binding Name}" FontWeight="Bold" Grid.Column="1" VerticalAlignment="Center" FontSize="16"/>
<TextBlock Text="LastName: " Grid.Column="2" VerticalAlignment="Center" FontSize="16"/>
<TextBlock Text="{Binding LastName}" FontWeight="Bold" Grid.Column="3" VerticalAlignment="Center" FontSize="16"/>
<TextBlock Text="Click me" Grid.Column="4" FontSize="16" MouseUp="MyMouseUp" Background="AliceBlue"/>
</Grid>
</GroupBox>
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
<TextBox Name="Results" IsReadOnly="True" FontSize="14" ScrollViewer.VerticalScrollBarVisibility="Auto" Height="Auto" Grid.Row="1" />
</Grid>
</Window>
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Input;
namespace DemoApp {
public partial class MainWindow : Window {
public class Data {
public string Name { get; set; }
public string LastName { get; set; }
} //
public MainWindow() {
InitializeComponent();
List<Data> lItems = new List<Data>() {
new Data() {Name = "Otto", LastName = "Waalkes"},
new Data() {Name = "Heinz", LastName = "Rühmann"},
new Data() {Name = "Michael", LastName = "Herbig"},
new Data() {Name = "Sky", LastName = "du Mont"},
new Data() {Name = "Dieter", LastName = "Hallervorden"},
new Data() {Name = "Diether", LastName = "Krebs"},
new Data() {Name = "Helga", LastName = "Feddersen"},
new Data() {Name = "Herbert", LastName = "Grönemeyer"},
};
MyListView.ItemsSource = lItems;
} //
// bubbling
private void MyMouseUp(object sender, MouseButtonEventArgs e) {
FrameworkElement lElement = sender as FrameworkElement;
string lAppend = Environment.NewLine;
if (sender is Window) lAppend += Environment.NewLine;
Results.Text += e.RoutedEvent.RoutingStrategy.ToString() + ": " + lElement.ToString() + lAppend;
e.Handled = false;
Results.ScrollToEnd();
} //
// tunneling
private void MyPreviewMouseUp(object sender, MouseButtonEventArgs e) {
FrameworkElement lElement = sender as FrameworkElement;
string lAppend = Environment.NewLine;
if (sender.Equals(e.OriginalSource)) lAppend += Environment.NewLine;
Results.Text += e.RoutedEvent.RoutingStrategy.ToString() + ": " + lElement.ToString() + lAppend;
e.Handled = false;
Results.ScrollToEnd();
} //
} // class
} // namespace
Tunneling Events are raised before Bubbling Events. The convention for Tunneling Events in .Net is that names have to start with the prefix “Preview”. Therefore The “MouseUp” event is a Bubbling Event and “PreviewMouseUp” is a Tunneling Event.
Today’s XAML source code subscribes to bubbling/tunneling events at several places. Compare the output with the code. In theory you could deal with all events on the window level. Use the e.OriginalSource field of the event argument MouseButtonEventArgs e to distinguish between the many possible events. You will also receive events that you did not explicitly subscribe to. Click into the lower textbox or on a scroll bar; this will raise events on the Grid, (ListView) and Window.
Now, let’s add a tunneling event to the “Click me” TextBlock.
<TextBlock Text="Click me" Grid.Column="4" FontSize="16" MouseUp="MyMouseUp" PreviewMouseUp="MyPreviewMouseUp" Background="AliceBlue"/>
This activates the code that was redundant so far:
if (sender.Equals(e.OriginalSource)) lAppend += Environment.NewLine;
Custom Routed Events
How can we add a custom routed event? Just follow this pattern:
- Inherit an element from another class.
- Define a public static readonly RoutedEvent.
- Register that Event by using the EventManager.
- Add an “old school” C# event that forwards “old school” subscriptions to your WPF routed event.
And here we go. Let’s add a button with a triple click event.
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
namespace DemoApp {
public class TripleClickButton : Button {
/*
* The methods AddHandler, RemoveHandler and RaiseEvent are inherited from UIElement
*/
// public static readonly !
public static readonly RoutedEvent TripleClickEvent = EventManager.RegisterRoutedEvent("TripleClick", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(TripleClickButton));
// Link classical approach to the above WPF RoutedEvent.
// Do not add any complex code here!
public event RoutedEventHandler TripleClick {
add { AddHandler(TripleClickEvent, value); }
remove { RemoveHandler(TripleClickEvent, value); }
} //
// How to trigger our Routed Event.
void RaiseTripleClickEvent() {
RoutedEventArgs lRoutedEventArgs = new RoutedEventArgs(TripleClickButton.TripleClickEvent);
RaiseEvent(lRoutedEventArgs);
} //
private List<DateTime> _Clicks = new List<DateTime>();
protected override void OnClick() {
lock (_Clicks) { // In theory we do not need a lock, because the event is always raised on the Dispatcher thread.
DateTime lNow = DateTime.Now;
_Clicks.Add(lNow);
if (_Clicks.Count < 3) return;
if (lNow.Subtract(_Clicks[0]).TotalMilliseconds < 1000) {
_Clicks.Clear();
RaiseTripleClickEvent();
return;
}
_Clicks.RemoveAt(0);
}
} //
} // class
} // namespace
Declare the new class in the XAML window namespace and replace the rightmost TextBlock by our new custom button.
<Window x:Class="DemoApp.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:app="clr-namespace:DemoApp"
...
<TextBlock Text="{Binding LastName}" FontWeight="Bold" Grid.Column="3" VerticalAlignment="Center" FontSize="16"/>
<app:TripleClickButton Content="TripleClick me" Grid.Column="4" FontSize="16" Background="Salmon" TripleClick="TripleClickButton_TripleClick" Tag="{Binding Name}" />
</Grid>
...
Define the event itself in the main window. Here is the full code:
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
namespace DemoApp {
public partial class MainWindow : Window {
public class Data {
public string Name { get; set; }
public string LastName { get; set; }
} //
public MainWindow() {
InitializeComponent();
List<Data> lItems = new List<Data>() {
new Data() {Name = "Otto", LastName = "Waalkes"},
new Data() {Name = "Heinz", LastName = "Rühmann"},
new Data() {Name = "Michael", LastName = "Herbig"},
new Data() {Name = "Sky", LastName = "du Mont"},
new Data() {Name = "Dieter", LastName = "Hallervorden"},
new Data() {Name = "Diether", LastName = "Krebs"},
new Data() {Name = "Helga", LastName = "Feddersen"},
new Data() {Name = "Herbert", LastName = "Grönemeyer"},
};
MyListView.ItemsSource = lItems;
} //
// bubbling
private void MyMouseUp(object sender, MouseButtonEventArgs e) {
FrameworkElement lElement = sender as FrameworkElement;
string lAppend = Environment.NewLine;
if (sender is Window) lAppend += Environment.NewLine;
Results.Text += e.RoutedEvent.RoutingStrategy.ToString() + ": " + lElement.ToString() + lAppend;
e.Handled = false;
Results.ScrollToEnd();
} //
// tunneling
private void MyPreviewMouseUp(object sender, MouseButtonEventArgs e) {
FrameworkElement lElement = sender as FrameworkElement;
string lAppend = Environment.NewLine;
if (sender.Equals(e.OriginalSource)) lAppend += Environment.NewLine;
Results.Text += e.RoutedEvent.RoutingStrategy.ToString() + ": " + lElement.ToString() + lAppend;
e.Handled = false;
Results.ScrollToEnd();
}
// custom event
private void TripleClickButton_TripleClick(object sender, RoutedEventArgs e) {
Button lButton = e.OriginalSource as Button;
if (lButton == null) return;
Results.Text = "TripleClick received from " + lButton.Tag;
} //
} // class
} // namespace
And the full XAML:
<Window x:Class="DemoApp.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:app="clr-namespace:DemoApp"
Title="MainWindow" Height="500" Width="630"
MouseUp="MyMouseUp" PreviewMouseUp="MyPreviewMouseUp">
<Grid MouseUp="MyMouseUp" PreviewMouseUp="MyPreviewMouseUp">
<Grid.RowDefinitions>
<RowDefinition Height="300" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<ListView Name="MyListView" Margin="0,0,0,0" Grid.IsSharedSizeScope="True" ScrollViewer.VerticalScrollBarVisibility="Auto" ScrollViewer.CanContentScroll="True" MouseUp="MyMouseUp" PreviewMouseUp="MyPreviewMouseUp" Grid.Row="0">
<ListView.ItemTemplate>
<DataTemplate>
<GroupBox Header="Item" FontSize="10">
<Grid PreviewMouseUp="MyPreviewMouseUp" MouseUp="MyMouseUp">
<Grid.ColumnDefinitions>
<ColumnDefinition />
<ColumnDefinition SharedSizeGroup="A" />
<ColumnDefinition />
<ColumnDefinition SharedSizeGroup="A" />
<ColumnDefinition />
</Grid.ColumnDefinitions>
<TextBlock Text="Name: " Grid.Column="0" VerticalAlignment="Center" FontSize="16" PreviewMouseUp="MyPreviewMouseUp"/>
<TextBlock Text="{Binding Name}" FontWeight="Bold" Grid.Column="1" VerticalAlignment="Center" FontSize="16"/>
<TextBlock Text="LastName: " Grid.Column="2" VerticalAlignment="Center" FontSize="16"/>
<TextBlock Text="{Binding LastName}" FontWeight="Bold" Grid.Column="3" VerticalAlignment="Center" FontSize="16"/>
<app:TripleClickButton Content="TripleClick me" Grid.Column="4" FontSize="16" Background="Salmon" TripleClick="TripleClickButton_TripleClick" Tag="{Binding Name}" />
</Grid>
</GroupBox>
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
<TextBox Name="Results" IsReadOnly="True" FontSize="14" ScrollViewer.VerticalScrollBarVisibility="Auto" Height="Auto" Grid.Row="1" />
</Grid>
</Window>
The next post will be about:
- Marking Routed Events as handled to avoid further processing.
- Suppressing the suppression of the Handled flag.
- Attached Events
- Style EventSetters
Stay tuned 😉
C# Hardcore Programming 