internal State(BinaryFormatter parent, SerializationHintsAttribute hints, Type t) { BinaryFormatter.WriteLine("New State: {0}", t != null ? t.FullName : "<null>"); TypeDescriptor td = (t != null) ? new TypeDescriptor(t) : null; m_parent = parent; m_value = new TypeHandler(parent, hints, td); }
public void Build_with_exactly_15_arguments() { //15 is the maximum number of arguments without having to put actions/funcs/predicates in an object array. //This comes from BuildLambdaExpression builds a Func, and Funcs may only have 16 input args: Func<T1,...,T16,TResult> //T1-argument is reserved for the obligatory value argument, which leaves us with 15 arguments to be used for the //actions/funcs/predicates string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> actionString = s => { }; Predicate <string> predicateString = s => false; for (var i = 0; i < 7; i++) { stringHandler.Handlers.Add(PredicateAndHandler.CreateAction(actionString, predicate: predicateString)); } typeHandlers.Add(stringHandler); var intHandler = new TypeHandler(typeof(int)); //Handle an int with one action Action <int> actionInt = i => { updatedValue = i.ToString(); }; var handler2 = PredicateAndHandler.CreateAction(actionInt); intHandler.Handlers.Add(handler2); typeHandlers.Add(intHandler); //Build the expression var builder = new MatchExpressionBuilder <object>(); var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(15, result.Arguments.Length, "Should contain the action and predicate delegates"); var lastArgument = result.Arguments.Last(); Assert.IsNotType <object[]>(lastArgument); //Last argument should not be an object[] //Compile the expression and test it var lambda = (Func <object, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <int>, bool>) result.LambdaExpression.Compile(); lambda("some value", actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionInt); Assert.Equal(null, updatedValue); lambda(4711, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionInt); Assert.Equal("4711", updatedValue); }
public static SnComponentInfo Create(ISnComponent component) { var asmVersion = TypeHandler.GetVersion(component.GetType().Assembly); if (component.SupportedVersion > asmVersion) { throw new ApplicationException($"Invalid component: {component.ComponentId}: supported version ({component.SupportedVersion}) cannot be greater than the assembly version ({asmVersion})."); } return(new SnComponentInfo { ComponentId = component.ComponentId, SupportedVersion = component.SupportedVersion ?? asmVersion, AssemblyVersion = asmVersion, IsComponentAllowed = component.IsComponentAllowed }); }
/// <summary> /// Insert rows in table or ignores if exists /// </summary> /// <param name="conn">A connection</param> /// <param name="table">Name of table to insert into</param> /// <param name="dataList">List of objects containing the data</param> /// <param name="pk">Name of primary key field</param> /// <param name="transaction">Transaction to associate with the command</param> /// <returns>Rows affected</returns> public static int InsertIfMissing(this DbConnection conn, string table, IEnumerable <object> dataList, string pk, DbTransaction transaction = null) { TypeDescriber td = TypeHandler.Get(dataList.First()); string columns = string.Join(",", td.WriteableColumns.Select(x => x.DbName)); string values = string.Join(",", dataList.Select((data, i) => $"({string.Join(",", td.WriteableColumns.Select(x => "@" + x.Property.Name + i))})")); string sql = $@" INSERT INTO {table} ({columns}) VALUES {values} ON CONFLICT ({pk}) DO NOTHING"; DbCommand cmd = conn.Prepare(sql, transaction); cmd.ApplyParameters(dataList); return(cmd.ExecuteNonQuery()); }
// This changes the type public void ChangeType(int typeindex) { // Can't do this for a fixed field! if (isfixed) { throw new InvalidOperationException(); } // Different? if (typeindex != fieldtype.Index) { // Change field type! TypeHandlerAttribute attrib = General.Types.GetAttribute(typeindex); fieldtype = General.Types.GetFieldHandler(typeindex, this.Cells[2].Value); this.Cells[1].Value = fieldtype.GetDisplayType(); } }
private void Load() { engines = new Dictionary <string, IEvaluator>(); foreach (var type in TypeHandler.GetTypesByInterface(typeof(IEvaluator))) { var attrs = (ScriptTagNameAttribute[])type.GetCustomAttributes(typeof(ScriptTagNameAttribute), false); if (attrs.Length == 0) { throw new ApplicationException(String.Concat( "Evaluator has not ScriptTagNameAttribute: ", type.FullName, " (Assembly: ", type.Assembly.ToString(), ")")); } var engine = (IEvaluator)Activator.CreateInstance(type); engines.Add(attrs[0].TagName, engine); Logger.WriteInformation(String.Concat("Add Evaluator: ", attrs[0].TagName, "."), Logger.GetDefaultProperties, engine); } }
public void Encode(object data, IClient client, IBinaryWriter writer) { using (IWriteBlock msgsize = writer.Allocate4Bytes()) { int length = (int)writer.Length; TypeHandler.WriteType(data, writer); using (IWriteBlock bodysize = writer.Allocate4Bytes()) { int bodyStartlegnth = (int)writer.Length; string strData = Newtonsoft.Json.JsonConvert.SerializeObject(data); writer.Write(strData); bodysize.SetData((int)writer.Length - bodyStartlegnth); } msgsize.SetData((int)writer.Length - length); } }
/// <summary> /// Insert rows in table or ignores if exists /// </summary> /// <param name="conn">A connection</param> /// <param name="table">Name of table to insert into</param> /// <param name="dataList">List of objects containing the data</param> /// <param name="pk">Name of primary key field</param> /// <param name="transaction">Transaction to associate with the command</param> /// <param name="cancellationToken">Cancellationtoken</param> /// <returns>Rows affected</returns> public static async Task <int> InsertIfMissingAsync(this DbConnection conn, string table, IEnumerable <object> dataList, string pk, DbTransaction transaction = null, CancellationToken cancellationToken = default) { TypeDescriber td = TypeHandler.Get(dataList.First()); string columns = string.Join(",", td.WriteableColumns.Select(x => x.DbName)); string values = string.Join(",", dataList.Select((data, i) => $"({string.Join(",", td.WriteableColumns.Select(x => "@" + x.Property.Name + i))})")); string sql = $@" INSERT INTO {table} ({columns}) VALUES {values} ON CONFLICT ({pk}) DO NOTHING"; DbCommand cmd = await conn.PrepareAsync(sql, transaction, cancellationToken).ConfigureAwait(false); cmd.ApplyParameters(dataList); return(await cmd.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false)); }
public override void Save(NodeSaveSettings settings) { // Check uniqueness first CheckUniqueUser(); if (base.IsPropertyChanged("CreationDate")) { if (_password != null) { this.PasswordHash = PasswordHashProvider.EncodePassword(_password, this); } } Domain = GenerateDomain(); var originalId = this.Id; // save current password to the list of old passwords this.SaveCurrentPassword(); base.Save(settings); // AD Sync SynchUser(originalId); // set creator for performant self permission setting // creator of the user will always be the user itself. this way setting permissions to the creators group on /Root/IMS will be adequate for user permissions // if you need the original creator, use the auditlog if (originalId == 0) { //need to clear this flag to avoid getting an 'Id <> 0' error during copying this.CopyInProgress = false; this.CreatedBy = this; this.VersionCreatedBy = this; this.DisableObserver(TypeHandler.GetType(NodeObserverNames.NOTIFICATION)); this.DisableObserver(TypeHandler.GetType(NodeObserverNames.WORKFLOWNOTIFICATION)); base.Save(SavingMode.KeepVersion); } // create profiles if (originalId == 0 && Repository.UserProfilesEnabled) { CreateProfile(); } }
internal void DoStart() { ConsoleWriteLine(); ConsoleWriteLine("Starting Repository..."); ConsoleWriteLine(); LoggingSettings.SnTraceConfigurator.UpdateStartupCategories(); TypeHandler.Initialize(_settings.Providers); InitializeLogger(); // Lucene subsystem behaves strangely if the enums are not initialized. var x = Lucene.Net.Documents.Field.Index.NO; var y = Lucene.Net.Documents.Field.Store.NO; var z = Lucene.Net.Documents.Field.TermVector.NO; CounterManager.Start(); RegisterAppdomainEventHandlers(); if (_settings.IndexPath != null) { StorageContext.Search.SetIndexDirectoryPath(_settings.IndexPath); } RemoveIndexWriterLockFile(); _startupInfo.IndexDirectory = System.IO.Path.GetDirectoryName(StorageContext.Search.IndexLockFilePath); LoadAssemblies(); SenseNet.ContentRepository.Storage.Security.SecurityHandler.StartSecurity(_settings.IsWebContext); using (new SenseNet.ContentRepository.Storage.Security.SystemAccount()) StartManagers(); LoggingSettings.SnTraceConfigurator.UpdateCategories(); InitializeOAuthProviders(); ConsoleWriteLine(); ConsoleWriteLine("Repository has started."); ConsoleWriteLine(); _startupInfo.Started = DateTime.UtcNow; }
protected override string GetQueryFilter() { var originalQueryFilter = base.GetQueryFilter(); if (SearchForm == null) { return(originalQueryFilter); } SearchForm.UpdateContent(); DefaultQueryBuilder qBuilder; if (string.IsNullOrEmpty(PluginFullPath)) { qBuilder = new DefaultQueryBuilder(originalQueryFilter, SearchForm.Content, EmptyQueryTerm); } else { qBuilder = TypeHandler.CreateInstance(PluginFullPath, new object[] { originalQueryFilter, SearchForm.Content }) as DefaultQueryBuilder; } var filter = qBuilder.BuildQuery(/*kv*/); var sb = new StringBuilder(); var writer = XmlWriter.Create(sb); writer.WriteStartDocument(); writer.WriteStartElement("ContentMetaData"); writer.WriteElementString("ContentType", SearchForm.Content.ContentType.Name); writer.WriteElementString("ContentName", SearchForm.Content.Name); writer.WriteStartElement("Fields"); SearchForm.Content.ExportFieldData(writer, new ExportContext("/Root", "")); writer.WriteEndElement(); writer.WriteEndElement(); writer.Flush(); writer.Close(); _state.ExportQueryFields = sb.ToString(); PortletState.Persist(_state); return(filter); }
public void ApplyMigrations(ApplyMigrationCriteria criteria) { var repoInfo = TypeHandler.FindSingleRepo(criteria.ProjectPath, criteria.RepoName); if (repoInfo == null) { return; } var repoBase = TypeHandler.CreateRepoBase(repoInfo.Assembly.Location, repoInfo.RepoType); var connectionString = ConnectionStringHandler.FindConnectionString(repoBase, criteria.ConfigFilePath); ConnectionStringHandler.OverrideConnectionString(repoBase, connectionString); var migrationTypes = TypeHandler.FindAllMigrations(criteria.ProjectPath, repoInfo.RepoType); if (migrationTypes == null || !migrationTypes.Any()) { LoggerBase.Log("No migrations to run."); return; } var migrationRepo = new MigrationRepo(connectionString); var doneMigrations = migrationRepo.GetMigrationsThatHaveRun(repoInfo.RepoType.Name); //only run on migrations that have not been run yet. //order by name, ie. datestamp. foreach (var migrationType in migrationTypes.Where(m => !doneMigrations.Contains(m.Name)).OrderBy(m => m.Name)) { var migration = Activator.CreateInstance(migrationType) as AbstractBaseMigration; if (migration == null) { LoggerBase.Log("Error creating migration: " + migrationType.Name); throw new ApplicationException("Error creating migration: " + migrationType.Name); } //use reflection to set the internal base repo PropertyInfo baseRepoPropertyInfo = migrationType.GetProperty("BaseRepo", BindingFlags.Instance | BindingFlags.NonPublic); baseRepoPropertyInfo.SetValue(migration, repoBase); LoggerBase.Log(string.Format("Executing Migration: {0}", migrationType.Name)); migration.Execute(); migrationRepo.LogMigrationRan(migrationType.Name, repoInfo.RepoType.Name); } }
private void SaveFieldSetting() { var fsName = this.Name; if (!fsName.StartsWith("#")) { fsName = string.Concat("#", fsName); } if (this._isNew) { //set field index default to int.Max to place //the new field at the end of the field list this.FieldIndex = int.MaxValue; } if (this._isNew && this.ContentList.FieldSettings.Any(fs => fs.Name.CompareTo(fsName) == 0)) { //field already exists with this name throw new InvalidOperationException(HttpContext.GetGlobalResourceObject("FieldEditor", "FieldError_FieldExists") as string); } if (string.Compare(this.FieldSetting.Name, fsName) != 0) { //field setting was renamed, remove the old one this.ContentList.DeleteField(this.FieldSetting); this.FieldSetting.Name = fsName; } this.ContentList.AddOrUpdateField(this.FieldSetting); if (!this._isNew || !this.AddToDefaultView) { return; } //add to default view var ivm = TypeHandler.ResolveNamedType <IViewManager>("ViewManager"); if (ivm != null) { ivm.AddToDefaultView(this.FieldSetting, this.ContentList); } }
/// <summary> /// Insert rows in table or updates if exists /// </summary> /// <param name="conn">A connection</param> /// <param name="table">Name of table to upsert into</param> /// <param name="dataList">List of objects containing the data</param> /// <param name="pk">Name of primary key field</param> /// <param name="transaction">Transaction to associate with the command</param> /// <param name="cancellationToken">Cancellationtoken</param> /// <returns>IEnumerable of true when inserted, false when updated</returns> public static async Task <IEnumerable <bool> > UpsertAsync(this DbConnection conn, string table, IEnumerable <object> dataList, string pk, DbTransaction transaction = null, CancellationToken cancellationToken = default) { TypeDescriber td = TypeHandler.Get(dataList.First()); string columns = string.Join(",", td.WriteableColumns.Select(x => x.DbName)); string values = string.Join(",", dataList.Select((data, i) => $"({string.Join(",", td.WriteableColumns.Select(x => "@" + x.Property.Name + i))})")); string set = string.Join(",", td.WriteableColumns.Select(x => x.DbName + "=excluded." + x.DbName)); string sql = $@" INSERT INTO {table} ({columns}) VALUES {values} ON CONFLICT ({pk}) DO UPDATE SET {set} RETURNING (xmax = 0) as inserted"; DbCommand cmd = await conn.PrepareAsync(sql, transaction, cancellationToken).ConfigureAwait(false); cmd.ApplyParameters(dataList); return(await conn.ScalarListAsync <bool>(cmd, cancellationToken).ToListAsync().ConfigureAwait(false)); }
/// <summary> /// Insert rows in table or updates if exists /// </summary> /// <param name="conn">A connection</param> /// <param name="table">Name of table to upsert into</param> /// <param name="dataList">List of objects containing the data</param> /// <param name="pk">Name of primary key field</param> /// <param name="transaction">Transaction to associate with the command</param> /// <returns>IEnumerable of true when inserted, false when updated</returns> public static IEnumerable <bool> Upsert(this DbConnection conn, string table, IEnumerable <object> dataList, string pk, DbTransaction transaction = null) { TypeDescriber td = TypeHandler.Get(dataList.First()); string columns = string.Join(",", td.WriteableColumns.Select(x => x.DbName)); string values = string.Join(",", dataList.Select((data, i) => $"({string.Join(",", td.WriteableColumns.Select(x => "@" + x.Property.Name + i))})")); string set = string.Join(",", td.WriteableColumns.Select(x => x.DbName + "=excluded." + x.DbName)); string sql = $@" INSERT INTO {table} ({columns}) VALUES {values} ON CONFLICT ({pk}) DO UPDATE SET {set} RETURNING (xmax = 0) as inserted"; DbCommand cmd = conn.Prepare(sql, transaction); cmd.ApplyParameters(dataList); return(conn.ScalarList <bool>(cmd)); }
public void Register(Type type, string fullPath) { if (_cache.IsExist(type)) { return; } if (ReflectionHelper.HasAttribute <ScriptIgnoreAttribute>(type)) { return; } var handler = new TypeHandler(_luaState); handler.Initilaze(new object[] { type, fullPath }); handler.Reg2Env(); _cache.Add(type, handler); }
public void Packaging_EzRelease_CreateComponentInfo_SupportedVersionGreaterThanThisVersion() { var thisVersion = TypeHandler.GetVersion(this.GetType().Assembly); var supportedVersion = new Version(thisVersion.Major, thisVersion.Minor + 1, 0); var supportedVersionString = supportedVersion.ToString(); var componentName = "TestComponent-1"; var component = new TestComponent(componentName, supportedVersionString, false); try { var componentInfo = SnComponentInfo.Create(component); Assert.Fail(); } catch (ApplicationException) { // do nothing } }
public Node CreateInstance(Node parent) { if (parent == null) { throw new ArgumentNullException("parent"); } if (_type == null) { _type = TypeHandler.GetType(_className); } if (_type == null) { string exceptionMessage = String.Concat("Type not found, therefore the node can't be created.", "\nClass name: ", _className, "\nNode type path: ", _nodeTypePath, "\nParent class name: ", (_parent != null ? _parent._className : "Parent is null"), "\n"); throw new ApplicationException(exceptionMessage); } //---- only public ctor is valid: public NodeDescendant(Node parent, string nodeTypeName) ConstructorInfo ctor = _type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, _newArgTypes, null); if (ctor == null) { throw new TypeInitializationException(String.Concat("Constructor not found. Valid signature: ctor(Node, string).\nClassName: ", _className), null); } Node node; try { node = (Node)ctor.Invoke(new object[] { parent, this.Name }); } catch (Exception ex) //rethrow { throw new ApplicationException(String.Concat("Couldn't create an instance of type '", _className, "'. The invoked constructor threw an exception of type ", ex.GetType().Name, " (it said '", ex.Message, "')."), ex); } return(node); }
/// <summary> /// Read data from database /// </summary> /// <typeparam name="T">class to map data to</typeparam> /// <param name="conn">A connection</param> /// <param name="cmd">Command to be executed</param> /// <returns>IEnumerable of T</returns> public static IEnumerable <T> Query <T>(this DbConnection conn, DbCommand cmd) where T : new() { using (var reader = cmd.ExecuteReader()) { var td = TypeHandler.Get <T>(); while (reader.Read()) { var result = new T(); for (var i = 0; i < reader.FieldCount; i++) { td.SetValue(reader.GetName(i), result, reader.GetValueWithNull(i)); } yield return(result); } } }
/// <summary> /// Read data from database /// </summary> /// <typeparam name="T">class to map data to</typeparam> /// <param name="conn">A connection</param> /// <param name="cmd">Command to be executed</param> /// <param name="cancellationToken">Cancellationtoken</param> /// <returns>IAsyncEnumerable of T</returns> public static async IAsyncEnumerable <T> QueryAsync <T>(this DbConnection conn, DbCommand cmd, [EnumeratorCancellation] CancellationToken cancellationToken = default) where T : new() { using (var reader = await cmd.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false)) { var td = TypeHandler.Get <T>(); while (await reader.ReadAsync(cancellationToken).ConfigureAwait(false)) { var result = new T(); for (var i = 0; i < reader.FieldCount; i++) { td.SetValue(reader.GetName(i), result, reader.GetValueWithNull(i)); } yield return(result); } } }
public static File CreateByBinary(IFolder parent, BinaryData binaryData) { if (parent == null) { throw new ArgumentNullException("parent"); } if (binaryData == null) { return(new File(parent as Node)); } File file; // Resolve filetype by binary-config matching BinaryTypeResolver resolver = new BinaryTypeResolver(); if (!resolver.ParseBinary(binaryData)) { // Unknown file type file = new File(parent as Node); } else { // Specific File subtype has been found file = TypeHandler.CreateInstance <File>(resolver.NodeType.ClassName, parent); var fname = binaryData.FileName.FileNameWithoutExtension; if (string.IsNullOrEmpty(fname)) { fname = file.Name; } else if (fname.Contains("\\")) { fname = System.IO.Path.GetFileNameWithoutExtension(fname); } binaryData.FileName = new BinaryFileName(fname, resolver.FileNameExtension); binaryData.ContentType = resolver.ContentType; } file.Binary = binaryData; return(file); }
private void CreateLayout() { switch (PortletType) { case PreviewPortletType.ContentCollectionPortlet: var collectionPortlet = TypeHandler.CreateInstance("SenseNet.Portal.Portlets.ContentCollectionPortlet") as ContextBoundPortlet; collectionPortlet.ID = "previewedPortlet"; collectionPortlet.BindTarget = SenseNet.Portal.UI.PortletFramework.BindTarget.CustomRoot; collectionPortlet.CustomRootPath = CustomRootPath; collectionPortlet.RenderingMode = RenderingMode; collectionPortlet.Renderer = Renderer; //this.form1.Controls.Add(collectionPortlet); renderedContent.Controls.Add(collectionPortlet); break; default: break; } }
public void Build_two_actions_and_predicate_for_same_type() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> action1 = s => { updatedValue = s; }; Predicate <string> predicate1 = s => s.Length > 5 && s.Length < 15; var handler1 = PredicateAndHandler.CreateAction(action1, predicate: predicate1); stringHandler.Handlers.Add(handler1); Action <string> action2 = s => { updatedValue = "action2"; }; Predicate <string> predicate2 = s => s.Length >= 15 && s.Length < 20; var handler2 = PredicateAndHandler.CreateAction(action2, predicate: predicate2); stringHandler.Handlers.Add(handler2); typeHandlers.Add(stringHandler); var builder = new MatchExpressionBuilder <object>(); //Build the expression var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(4, result.Arguments.Length, "Should contain the action and predicate delegate"); Assert.Same(action1, result.Arguments[0]); Assert.Same(predicate1, result.Arguments[1]); Assert.Same(action2, result.Arguments[2]); Assert.Same(predicate2, result.Arguments[3]); //Compile the expression and test it var lambda = (Func <object, Action <String>, Predicate <string>, Action <String>, Predicate <string>, bool>)result.LambdaExpression.Compile(); lambda("short", action1, predicate1, action2, predicate2); Assert.Equal(null, updatedValue); lambda("longer value", action1, predicate1, action2, predicate2); Assert.Equal("longer value", updatedValue); lambda("1234567890123456789", action1, predicate1, action2, predicate2); Assert.Equal("action2", updatedValue); lambda(4711, action1, predicate1, action2, predicate2); Assert.Equal("action2", updatedValue); }
public void Encode(object data, IClient client, IBinaryWriter writer) { Message msg = data as Message; if (msg != null) { msg.Track("message GetType"); msg.DataType = TypeHandler.GetMessageType(msg.Data.GetType()).TypeName; } using (IWriteBlock msgsize = writer.Allocate4Bytes()) { int length = (int)writer.Length; TypeHandler.WriteType(data, writer); using (IWriteBlock bodysize = writer.Allocate4Bytes()) { int bodyStartlegnth = (int)writer.Length; data.Serialize(writer.Stream); bodysize.SetData((int)writer.Length - bodyStartlegnth); } if (msg != null) { msg.Track("message write body"); using (IWriteBlock datasize = writer.Allocate4Bytes()) { int dataStartlength = (int)writer.Length; object body = msg.Data; if (body is ISerializer) { ((ISerializer)body).Serialize(writer); } else { msg.Data.Serialize(writer.Stream); } datasize.SetData((int)writer.Length - dataStartlength); } msg.Track("message write body completed!"); msg.Track("message size:" + writer.Length); } msgsize.SetData((int)writer.Length - length); } }
/// <summary> /// Gets the data base value. /// </summary> /// <param name="dataReader">The data reader.</param> /// <returns></returns> public object GetDataBaseValue(IDataReader dataReader) { object value = null; ///Add by me. 用列名称解决分页之后造成的下标错位问题 if (!string.IsNullOrEmpty(ColumnName)) { value = TypeHandler.GetValueByName(this, dataReader); } /// else if (columnIndex == UNKNOWN_COLUMN_INDEX) { value = TypeHandler.GetValueByName(this, dataReader); } else { value = TypeHandler.GetValueByIndex(this, dataReader); } bool wasNull = (value == DBNull.Value); if (wasNull) { if (this.HasNullValue) { if (setAccessor != null) { value = TypeHandler.ValueOf(setAccessor.MemberType, nullValue); } else { value = TypeHandler.ValueOf(null, nullValue); } } else { value = TypeHandler.NullValue; } } return(value); }
public EModel UseDefaultConstructor() { if (TypeHandler.IsClass && !TypeHandler.IsArray && TypeHandler != typeof(string) && Builder != null) { //使用默认构造函数 ConstructorInfo ctor = TypeHandler.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null); if (ctor == null) { throw new InvalidOperationException("Type [" + TypeHandler.FullName + "] should have default public or non-public constructor"); } il.REmit(OpCodes.Newobj, ctor); il.EmitStoreBuilder(Builder); } else if (IsStruct) { il.REmit(OpCodes.Ldloca_S, Builder); il.InitObject(TypeHandler); } return(this); }
private static void LoadProperty(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM, ResultMap resultMap) { var resultNodes = xmlNode.SelectNodes("./ns:Result", xmlNsM); foreach (XmlNode resultNode in resultNodes) { var property = new Property { Name = resultNode.Attributes["Property"].Value, Column = (resultNode.Attributes["Column"] ?? resultNode.Attributes["Property"]).Value, TypeHandler = resultNode.Attributes["TypeHandler"]?.Value }; if (!String.IsNullOrEmpty(property.TypeHandler)) { TypeHandler typeHandler = TypeHanderNotNull(sqlMapConfig, property.TypeHandler); property.Handler = typeHandler.Handler; } resultMap.Properties.Add(property); } }
public void Decode(IClient client, IBinaryReader reader) { START: try { object data; if (mSize == 0) { if (reader.Length < 4) { return; } mSize = reader.ReadInt32(); } if (reader.Length < mSize) { return; } Type type = TypeHandler.ReadType(reader); int bodySize = reader.ReadInt32(); data = Newtonsoft.Json.JsonConvert.DeserializeObject(reader.ReadString(bodySize), type); mSize = 0; try { if (Completed != null) { Completed(client, data); } } catch (Exception e_) { client.ProcessError(e_, "client packet process object error!"); } goto START; } catch (Exception e_) { client.ProcessError(e_, "client packet decode error!"); client.DisConnect(); } }
internal static bool IsComponentAllowed(SnComponentInfo component, Version installedComponentVersion) { return(true); if (installedComponentVersion == null) { throw new InvalidOperationException($"{component.ComponentId} component is missing."); } var assemblyVersion = component.AssemblyVersion ?? TypeHandler.GetVersion(component.GetType().Assembly); // To be able to publish code hotfixes, we allow the revision number (the 4th element) // to be higher in the assembly (in case every other part equals). This assumes // that every repository change raises at least the build number (the 3rd one) // in the component's version. if (installedComponentVersion.Major != assemblyVersion.Major || installedComponentVersion.Minor != assemblyVersion.Minor || installedComponentVersion.Build != assemblyVersion.Build) { // Not allowed if the assembly is older than the matched component. if (assemblyVersion < installedComponentVersion) { return(false); } // Not allowed if the component is older than the assembly can support. if (installedComponentVersion < component.SupportedVersion) { return(false); } } // Call the customized function if there is. if (component.IsComponentAllowed != null) { return(component.IsComponentAllowed.Invoke(installedComponentVersion)); } // Everything is fine, assembly is runnable. return(true); }
/// <summary> /// Deserialize a TypeHandler object /// </summary> /// <param name="node"></param> /// <param name="configScope"></param> /// <returns></returns> public static void Deserialize(XmlNode node, ConfigurationScope configScope) { TypeHandler handler = new TypeHandler(); NameValueCollection prop = NodeUtils.ParseAttributes(node, configScope.Properties); handler.CallBackName = NodeUtils.GetStringAttribute(prop, "callback"); handler.ClassName = NodeUtils.GetStringAttribute(prop, "type"); handler.DbType = NodeUtils.GetStringAttribute(prop, "dbType"); handler.Initialize(); configScope.ErrorContext.MoreInfo = "Check the callback attribute '" + handler.CallBackName + "' (must be a classname)."; ITypeHandler typeHandler = null; Type type = configScope.SqlMapper.TypeHandlerFactory.GetType(handler.CallBackName); object impl = Activator.CreateInstance(type); if (impl is ITypeHandlerCallback) { typeHandler = new CustomTypeHandler((ITypeHandlerCallback)impl); } else if (impl is ITypeHandler) { typeHandler = (ITypeHandler)impl; } else { throw new ConfigurationErrorsException("The callBack type is not a valid implementation of ITypeHandler or ITypeHandlerCallback"); } // configScope.ErrorContext.MoreInfo = "Check the type attribute '" + handler.ClassName + "' (must be a class name) or the dbType '" + handler.DbType + "' (must be a DbType type name)."; if (handler.DbType != null && handler.DbType.Length > 0) { configScope.DataExchangeFactory.TypeHandlerFactory.Register(TypeUtils.ResolveType(handler.ClassName), handler.DbType, typeHandler); } else { configScope.DataExchangeFactory.TypeHandlerFactory.Register(TypeUtils.ResolveType(handler.ClassName), typeHandler); } }
static SnJsonConverter() { var fieldConverterTypes = TypeHandler.GetTypesByBaseType(typeof(FieldConverter)); _jsonConverters = new List <JsonConverter>(); _fieldConverters = new List <FieldConverter>(); foreach (var fieldConverterType in fieldConverterTypes) { var fieldConverter = (FieldConverter)Activator.CreateInstance(fieldConverterType); _jsonConverters.Add(fieldConverter); _fieldConverters.Add(fieldConverter); } _jsonSettings = new JsonSerializerSettings() { DateFormatHandling = DateFormatHandling.IsoDateFormat, Formatting = Formatting.Indented, Converters = JsonConverters }; }
public static IDisposable Override(TypeHandler handler) { return new TypeHandlerOverride(handler); }
public TypeHandlerOverride(TypeHandler handler) { current = handler; }