private void RegisterMultipleComponentsRegistration(ComponentRegistryDefinition componentRegistryDefinition, ComponentRegistryDefinition.ComponentSetRegistrationDefinition componentSetRegistrationDefinition) { if (componentSetRegistrationDefinition.RegistrationsDefinition == null) { return; } foreach (var registration in componentSetRegistrationDefinition.RegistrationsDefinition) { TypeSwitch.Do(registration, TypeSwitch.Case <ComponentRegistryDefinition.ComponentRegistrationDefinition>(componentRegistration => { componentRegistration.Interface = componentSetRegistrationDefinition.Interface; RegisterMutipleComponentComponentRegistration( componentRegistryDefinition, componentRegistration ); }), TypeSwitch.Case <ComponentRegistryDefinition.ProxyInterfaceRegistrationDefinition>(proxyRegistration => { proxyRegistration.Interface = componentSetRegistrationDefinition.Interface; RegisterMultipleComponentProxyRegistration( componentRegistryDefinition, proxyRegistration ); }), TypeSwitch.Default(() => { throw new NotSupportedException(registration.GetType().FullName); }) ); } }
private void ValidateRequestSettings(IRequestSettings <T> config, IContactRequest typeRequest) { TypeSwitch.Do( config.mailingProvider, TypeSwitch.Case <IIContactRequest>(() => { IContactValidateRequestSettings(config, typeRequest); }), TypeSwitch.Default(() => { })); }
public override ISQLBuilder Literal(object value) { if (value != null) { TypeSwitch.Do( value, TypeSwitch.Case <byte[]>(x => Emit("X'").Emit(x.ToHexString(true)).Emit("'")), TypeSwitch.Case <Guid>(x => this.Literal(x.ToByteArray())), TypeSwitch.Case <Guid?>(x => { if (x.HasValue) { this.Literal(x.Value.ToByteArray()); } else { base.Literal(null); } }), TypeSwitch.Default(() => base.Literal(value)) ); } else { base.Literal(null); } return(this); }
public static string Beautify(object obj) { var val = string.Empty; if (obj != null) { TypeSwitch.Do(obj, TypeSwitch.Case <string>(s => val = s), TypeSwitch.Case <DateTime?>(dt => val = string.Format("{0:yyyy-MM-dd HH:mm:ss}", dt)), TypeSwitch.Case <DateTime>(dt => val = string.Format("{0:yyyy-MM-dd HH:mm:ss}", dt)), //TypeSwitch.Case<byte[]>(b => val = BitcoinProtocolHelper.BytesToString(b)), TypeSwitch.Case <decimal?>(d => val = string.Format("{0:0.#############################}", d)), TypeSwitch.Case <decimal>(d => val = string.Format("{0:0.#############################}", d)), TypeSwitch.Case <double?>(d => val = string.Format("{0:0.#############################}", d)), TypeSwitch.Case <double>(d => val = string.Format("{0:0.#############################}", d)), TypeSwitch.Case <float?>(d => val = string.Format("{0:0.#############################}", d)), TypeSwitch.Case <float>(d => val = string.Format("{0:0.#############################}", d)), TypeSwitch.Default(() => val = obj.ToString()) ); } else { val = string.Empty; } return(val); }
private static void Traverse(IGenericObject genericObject, IApp app) { if (genericObject == null) { return; } // Check if the object is an extensions of a master object. if (genericObject.Properties.ExtendsObject != null) { var masterObject = (IMasterObject)genericObject.Properties.ExtendsObject; TextHelper.WriteLine(4, "MasterObject version " + masterObject.Properties.MasterVersion); } // The information to print for each object depends on the type of the object. The TypeSwitch class can be used // for this purpose. For extensions of master objects, property values will automatically be retrieved from the // master object. TypeSwitch.Do(genericObject, TypeSwitch.Case <Table>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Barchart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Linechart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Piechart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Scatterplot>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Treemap>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Gauge>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Combochart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <TextImage>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)), TypeSwitch.Case <Listbox>(o => TextHelper.Print(o.GetType().Name, o.Title)), TypeSwitch.Case <Filterpane>(o => TextHelper.Print(o.GetType().Name, o.Title)), TypeSwitch.Case <Kpi>(o => TextHelper.Print(o.GetType().Name, o.Title)), TypeSwitch.Case <Pivottable>(o => TextHelper.Print(o.GetType().Name, o.Title)), TypeSwitch.Case <Map>(o => TextHelper.Print(o.GetType().Name, o.Title)), TypeSwitch.Default(() => TextHelper.WriteLine(4, "Unknown type: " + genericObject.GetType().FullName)) ); }
public void TypeSwitch_Default_ActionNull_Success() { var result = TypeSwitch.Default(null); result.Action.Invoke(null); Assert.AreEqual(null, result.Target); Assert.IsTrue(result.IsDefault); }
public void TypeSwitch_Do_WhenDefault_ExpectDefaultAndTargetNull() { //------------Execute Test--------------------------- var result = TypeSwitch.Default(delegate() { }); //------------Assert Results------------------------- Assert.AreEqual(null, result.Target); Assert.IsTrue(result.IsDefault); }
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "") { IDev2TOFn toReturn = null; TypeSwitch.Do(dto, // ReSharper disable ImplicitlyCapturedClosure TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)), // ReSharper restore ImplicitlyCapturedClosure TypeSwitch.Case <DataSplitDTO>(x => { var dataSplitDto = dto as DataSplitDTO; if (dataSplitDto != null) { toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted); } }), TypeSwitch.Case <DataMergeDTO>(x => { var dataMergeDto = dto as DataMergeDTO; if (dataMergeDto != null) { toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted); } }), TypeSwitch.Case <CaseConvertTO>(x => { var caseConvertTO = dto as CaseConvertTO; if (caseConvertTO != null) { toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index); } }), TypeSwitch.Case <BaseConvertTO>(x => { var baseConvertTO = dto as BaseConvertTO; if (baseConvertTO != null) { toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted); } }), // ReSharper disable ImplicitlyCapturedClosure TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn = // ReSharper restore ImplicitlyCapturedClosure new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime, initializeWith, index, inserted)), // ReSharper disable ImplicitlyCapturedClosure TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)), // ReSharper restore ImplicitlyCapturedClosure // ReSharper disable ImplicitlyCapturedClosure TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)), // ReSharper restore ImplicitlyCapturedClosure // ReSharper disable ImplicitlyCapturedClosure TypeSwitch.Default(() => toReturn = null)); // ReSharper restore ImplicitlyCapturedClosure return(toReturn); }
public void TypeSwitch_Do_WhenDefault_ExpectActionCalled() { var wasCalled = false; var case1 = TypeSwitch.Default(delegate { wasCalled = true; }); TypeSwitch.Do(typeof(object), case1); Assert.IsTrue(wasCalled, "expected action to be called"); }
public void DefaultCreatesCaseInfoObjectCorrectly() { Action action = () => {}; var result = TypeSwitch.Default(action); Assert.AreEqual(result.IsDefault, true); Assert.Throws <NullReferenceException>(() => Assert.AreEqual(result.Target, null)); Assert.AreEqual(result.Action, action); }
private void ConfigureRequest(HttpWebRequest request, IRequestSettings <T> config) { TypeSwitch.Do( config.mailingProvider, TypeSwitch.Case <IIContactRequest>(() => { //IContactConfigureRequest(request, config); IContactConfigureRequestJson(request, config); }), TypeSwitch.Default(() => { })); }
private string CreatetUriRequest(T mailingProvider, IContactRequest typeRequest) { string uri = string.Empty; TypeSwitch.Do( mailingProvider, TypeSwitch.Case <IIContactRequest>(() => { uri = IContactCreatetUriRequest(mailingProvider, typeRequest); }), TypeSwitch.Default(() => { uri = string.Empty; })); return(uri); }
void OnReturnInstanceSignalDispatched(PoolableView view) { TypeSwitch.Do( view, TypeSwitch.Case <PlayerShipLaserView>(x => playerLaserPool.ReturnInstance(x)), TypeSwitch.Case <AsteroidView>(x => asteroidPool.ReturnInstance(x)), TypeSwitch.Case <EnemyShipView>(x => enemyShipPool.ReturnInstance(x)), TypeSwitch.Default(() => { throw new NotSupportedException("This view can not supported!!!!!"); }) ); }
private IDataType GetDataType() { var dataType = string.Empty; TypeSwitch.Do( CurrentColumnInfo.Column.FieldNameType, TypeSwitch.Case <string>(() => dataType = "StringDataType"), TypeSwitch.Case <DateTime>(() => dataType = "DatetimeDataType"), TypeSwitch.Case <DateTime?>(() => dataType = "DatetimeDataType"), TypeSwitch.Default(() => dataType = "DefaultType") ); return(DataTypeFactory.GetInstance().CreateInstance(dataType)); }
public virtual ISQLBuilder Literal(object value) { if (value == null || value == DBNull.Value) { return(Emit("NULL")); } TypeSwitch.Do(value, TypeSwitch.Case <SQLBuilderCommand>(c => { c.Execute(this.LeafBuilder); }), TypeSwitch.Default(() => Emit(value.ToSQLString())) ); return(this); }
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index, bool inserted, string initializeWith) { IDev2TOFn toReturn = null; TypeSwitch.Do(dto, TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)), TypeSwitch.Case <DataSplitDTO>(x => { if (dto is DataSplitDTO dataSplitDto) { toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted); } }), TypeSwitch.Case <DataMergeDTO>(x => { if (dto is DataMergeDTO dataMergeDto) { toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted); } }), TypeSwitch.Case <CaseConvertTO>(x => { if (dto is CaseConvertTO caseConvertTO) { toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index); } }), TypeSwitch.Case <BaseConvertTO>(x => { if (dto is BaseConvertTO baseConvertTO) { toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted); } }), TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn = new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime, initializeWith, index, inserted)), TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)), TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)), TypeSwitch.Case <DecisionTO>(() => toReturn = new DecisionTO(initializeWith, "", "", index, inserted)), TypeSwitch.Case <JsonMappingTo>(() => toReturn = new JsonMappingTo(initializeWith, index, inserted)), TypeSwitch.Case <SharepointSearchTo>(() => toReturn = new SharepointSearchTo(initializeWith, "=", "", index, inserted)), TypeSwitch.Case <SharepointReadListTo>(() => toReturn = new SharepointReadListTo("", initializeWith, "", "")), TypeSwitch.Case <AssignObjectDTO>(x => toReturn = new AssignObjectDTO(initializeWith, "", index, inserted)), TypeSwitch.Default(() => toReturn = null)); return(toReturn); }
private StorageClass GetStorageClass(Type type) { var retval = StorageClass.XMLSerialized; TypeSwitch.DoType(type, TypeSwitch.Case <string>(() => retval = StorageClass.String), TypeSwitch.Case <int>(() => retval = StorageClass.Integer), TypeSwitch.Case <bool>(() => retval = StorageClass.Bool), TypeSwitch.Case <float>(() => retval = StorageClass.Float), TypeSwitch.Case <double>(() => retval = StorageClass.Double), TypeSwitch.Default(() => retval = StorageClass.XMLSerialized) ); return(retval); }
public void DoSelectsDefaultCaseIfTypesDoNotMatch() { var result = false; TypeSwitch.Do <object>( TypeSwitch.Case <string>(() => Assert.That(false, "Expected default case, got string")), TypeSwitch.Case <bool>(() => Assert.That(false, "Expected default case, got bool")), TypeSwitch.Case <int>(() => Assert.That(false, "Expected default case, got int")), TypeSwitch.Case <float>(() => Assert.That(false, "Expected default case, got float")), TypeSwitch.Default(() => result = true) ); Assert.That(result, "Default case was not invoked!"); }
public void OnException(ExceptionContext context) { TypeSwitch.Do(context.Exception, TypeSwitch.Case <HypermediaException>(() => this.HandleHypermediaException(context)), TypeSwitch.Case <HypermediaFormatterException>(() => this.HandleHypermediaException(context)), TypeSwitch.Case <UnauthorizedAccessException>(() => this.HandleUnauthorizedAccessException(context)), TypeSwitch.Default(() => GenericResponse(context)) ); if (this.logger != null) { this.logger.LogError("GlobalExceptionFilter", context.Exception); } }
private object GetObjectInstance(Type t, Canvas cv, object obj = null) { object o = null; TypeSwitch.CaseInfo[] cinfo = { TypeSwitch.Case <CollapsibleCategory>(() => { o = Activator.CreateInstance(t, new CollapsibleList(new ScrollControl(cv))); }), TypeSwitch.Case <DownArrow>(() => { o = Activator.CreateInstance(t, new ComboBox(cv)); }), TypeSwitch.Case <PropertyRow>(() => { o = Activator.CreateInstance(t, new object[]{ cv, new Gwen.Control.Property.PropertyBase(cv) }); }), TypeSwitch.Case <PropertyRowLabel>(() => { o = Activator.CreateInstance(t, new PropertyRow(cv, new Gwen.Control.Property.PropertyBase(cv))); }), TypeSwitch.Case <Margin>(() => { o = Activator.CreateInstance(t, new object[]{ 0, 0, 0, 0 }); }), TypeSwitch.Case <Padding>(() => { o = Activator.CreateInstance(t, new object[]{ 0, 0, 0, 0 }); }), TypeSwitch.Default(() => { o = Activator.CreateInstance(t, cv); }) }; if (obj == null) { TypeSwitch.Do(t, cinfo); } else { TypeSwitch.Do(obj, cinfo); } return(o); }
private static string TypeName <T>() where T : NeoValue { string name = null; TypeSwitch.Do <T>( TypeSwitch.Case <NeoProcedure>(() => name = "procedure"), TypeSwitch.Case <NeoObject>(() => name = "object"), TypeSwitch.Case <NeoArray>(() => name = "array"), TypeSwitch.Case <NeoFloat>(() => name = "float"), TypeSwitch.Case <NeoNumber>(() => name = "number"), TypeSwitch.Case <NeoInt>(() => name = "int"), TypeSwitch.Case <NeoBool>(() => name = "bool"), TypeSwitch.Default(() => name = typeof(T).ToString()) ); return(name); }
public void RemoveStateChangedHandler(Control control, EventHandler eventHandler) { TypeSwitch.Do( control, TypeSwitch.Case <ApplicationControl>(c => c.StateChanged -= eventHandler), TypeSwitch.Case <NumericUpDown>(c => c.ValueChanged -= eventHandler), TypeSwitch.Case <TextBox>(c => c.TextChanged -= eventHandler), TypeSwitch.Case <ComboBox>(c => c.SelectedIndexChanged -= eventHandler), TypeSwitch.Case <RadioButton>(c => c.CheckedChanged -= eventHandler), TypeSwitch.Case <CheckBox>(c => c.CheckedChanged -= eventHandler), TypeSwitch.Case <CheckedListBox>(c => c.SelectedIndexChanged -= eventHandler), TypeSwitch.Case <DateTimePicker>(c => c.TextChanged -= eventHandler), TypeSwitch.Case <ListBox>(c => c.SelectedIndexChanged -= eventHandler), TypeSwitch.Default(() => { throw new SoftwareException($"Control '{control.GetType().Name}' is not supported"); }) ); }
public override ISQLBuilder Literal(object value) { if (value == null || value == DBNull.Value) { return(Emit("NULL")); } TypeSwitch.Do( value, TypeSwitch.Case <byte[]>(x => { Emit("CONVERT(varbinary(max), "); base.Literal(value); Emit(" , 1)"); }), TypeSwitch.Default(() => base.Literal(value)) ); return(this); }
private static void SetPresentationAnchorInternal(UIPopoverPresentationController ppc, NSObject target, NSObject targetOwner) { TypeSwitch.Do(target, TypeSwitch.Case <UIToolbar>(b => { ppc.SourceView = b; ppc.SourceRect = b.Bounds; ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any; }), TypeSwitch.Case <UITabBar>(b => { ppc.SourceView = b; ppc.SourceRect = b.Bounds; ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any; }), TypeSwitch.Case <UITableViewCell>(cvc => { if (targetOwner == null || !(targetOwner is UITableView)) { throw new ArgumentNullException("UITargetReference to UITableViewCell did not contain the UITableView in TargetOwner field ", "targetOwner"); } ppc.SourceView = targetOwner as UITableView; ppc.SourceRect = cvc.Frame; ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any; }), TypeSwitch.Case <UICollectionViewCell>(cvc => { if (targetOwner == null || !(targetOwner is UICollectionView)) { throw new ArgumentNullException("UITargetReference to UICollectionViewCell did not contain the UICollectionView in TargetOwner field ", "targetOwner"); } ppc.SourceView = targetOwner as UICollectionView; ppc.SourceRect = cvc.Frame; ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any; }), TypeSwitch.Case <UIView>(v => { ppc.SourceView = v; ppc.SourceRect = v.Bounds; ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any; }), TypeSwitch.Case <UIBarButtonItem>((Action <UIBarButtonItem>)(b => { ppc.BarButtonItem = b; ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any; })), TypeSwitch.Default(() => { throw new NotSupportedException(target.GetType().ToString()); }) ); }
public bool CanObserve(object source) { bool canObserve = false; TypeSwitch.Do(source, TypeSwitch.Case <IStateChangeEventSource>(() => canObserve = true), TypeSwitch.Case <NumericUpDown>(() => canObserve = true), TypeSwitch.Case <IStateChangeEventSource>(() => canObserve = true), TypeSwitch.Case <TextBox>(() => canObserve = true), TypeSwitch.Case <ComboBox>(() => canObserve = true), TypeSwitch.Case <RadioButton>(() => canObserve = true), TypeSwitch.Case <CheckBox>(() => canObserve = true), TypeSwitch.Case <CheckedListBox>(() => canObserve = true), TypeSwitch.Case <DateTimePicker>(() => canObserve = true), TypeSwitch.Case <ListBox>(() => canObserve = true), TypeSwitch.Default(() => canObserve = false) ); return(canObserve); }
public override ISQLBuilder Literal(object value) { if (value == null || value == DBNull.Value) { return(Emit("NULL")); } TypeSwitch.Do( value, TypeSwitch.Case <Guid>(g => Emit("CHAR_TO_UUID('{0}')", g.ToString().ToUpper())), TypeSwitch.Case <byte[]>(x => { Emit("CONVERT(varbinary(max), "); base.Literal(value); Emit(" , 1)"); }), TypeSwitch.Default(() => base.Literal(value)) ); return(this); }
/// <summary> /// Handles the exception. /// </summary> /// <returns></returns> public HandledResponseModel HandleException() { var response = new HandledResponseModel(); TypeSwitch.Eval(Exception, TypeSwitch.Case <HandledException>(ex => { response = new HandledResponseModel() { StatusCode = (int)ex.StatusCode, Descriptor = BadRequestDescriptor, Exceptions = ToExResponse(ex) }; }), TypeSwitch.Case <HandledExceptionCollection>((ex) => { response = new HandledResponseModel() { StatusCode = (int)ex.StatusCode, Descriptor = BadRequestDescriptor, Exceptions = ToExResponse(ex) }; }), TypeSwitch.Case <Exception>((ex) => { response = new HandledResponseModel() { StatusCode = (int)HttpStatusCode.InternalServerError, Descriptor = BadRequestDescriptor, Exceptions = ToExResponse(ex) }; }), TypeSwitch.Default(() => { }) ); return(response); }
public static DeployViewModel GetDeployViewModel(object input) { DeployViewModel deployViewModel = null; if (input != null) { TypeSwitch.Do(input, TypeSwitch.Case <ExplorerItemModel>( x => deployViewModel = new DeployViewModel(x.ResourceId, x.EnvironmentId)), TypeSwitch.Case <ResourceModel>( x => deployViewModel = new DeployViewModel(x.ID, x.Environment.ID)), TypeSwitch.Default(() => deployViewModel = new DeployViewModel())); } else { deployViewModel = new DeployViewModel(); } return(deployViewModel); }
protected virtual VariableStorageClass TypeToStorageClass(Type type) { var storageClass = VariableStorageClass.Integer; if (type.IsIntegerNumeric()) { storageClass = VariableStorageClass.Integer; } else { TypeSwitch.ForType( type, TypeSwitch.Case <Guid>(() => storageClass = VariableStorageClass.Uuid), TypeSwitch.Case <string>(() => storageClass = VariableStorageClass.Text), TypeSwitch.Case <DateTime>(() => storageClass = VariableStorageClass.DateTime), TypeSwitch.Case <byte[]>(() => storageClass = VariableStorageClass.Blob), TypeSwitch.Default(() => { throw new SoftwareException("Unable to map type to variable storage class '{0}'", type.Name); }) ); } return(storageClass); }
public void TestTypeSwitch() { object v = null; object node = null; DoubleNode doubleNode = new DoubleNode(1.2); node = doubleNode; TypeSwitch.Do( node, TypeSwitch.Case <IntNode>(n => v = n.Value), TypeSwitch.Case <DoubleNode>(n => v = n.Value), TypeSwitch.Case <BooleanNode>(n => v = n.Value), TypeSwitch.Case <StringNode>(n => v = n.Value), TypeSwitch.Default(() => v = null)); Assert.AreEqual(v, 1.2); IntNode intNode = new IntNode(42); node = intNode; TypeSwitch.Do( node, TypeSwitch.Case <IntNode>(n => v = n.Value), TypeSwitch.Case <DoubleNode>(n => v = n.Value), TypeSwitch.Case <BooleanNode>(n => v = n.Value), TypeSwitch.Case <StringNode>(n => v = n.Value), TypeSwitch.Default(() => v = null)); Assert.AreEqual(v, 42); StringNode sNode = new StringNode(); node = sNode; TypeSwitch.Do( node, TypeSwitch.Case <IntNode>(n => v = n.Value), TypeSwitch.Case <DoubleNode>(n => v = n.Value), TypeSwitch.Case <BooleanNode>(n => v = n.Value), TypeSwitch.Default(() => v = 24)); Assert.AreEqual(v, 24); }