/// <summary> /// Adds the event handler to the content type. /// </summary> /// <param name="contentType">The content type.</param> /// <param name="name">The name of the event.</param> /// <param name="assembly">The assembly containin the event receiver.</param> /// <param name="className">Name of the event receiver class.</param> /// <param name="type">The event receiver type.</param> /// <param name="sequence">The sequence.</param> /// <param name="sync">The synchronization type.</param> public void AddEventHandler( SPContentType contentType, string name, string assembly, string className, SPEventReceiverType type, int sequence, SPEventReceiverSynchronization sync) { // Guard if (contentType == null) { throw new ArgumentNullException("contentType"); } SPEventReceiverDefinition definition = GetEventHandler(contentType.EventReceivers, name, type); if (definition == null) { contentType.EventReceivers.Add(type, assembly, className); definition = GetEventHandler(contentType.EventReceivers, className, type); } definition.Name = name; definition.SequenceNumber = sequence; definition.Synchronization = sync; definition.Update(); }
/// <summary> /// Registers an event receiver if required. /// </summary> /// <param name="this"> /// The this. /// </param> /// <param name="eventReceiverType"> /// The event receiver type. /// </param> /// <param name="assemblyName"> /// The assembly name. /// </param> /// <param name="className"> /// The class name. /// </param> /// <param name="synchronization"> /// The synchronization. /// </param> public static void RegisterEventReceiverIfRequired(this SPList @this, SPEventReceiverType eventReceiverType, string assemblyName, string className, SPEventReceiverSynchronization synchronization = SPEventReceiverSynchronization.Default) { // Validation.ArgumentIsNotNull(() => @this); // Validation.ArgumentIsNotNullOrWhitespace(() => assemblyName); // Validation.ArgumentIsNotNullOrWhitespace(() => className); SPEventReceiverDefinition eventReceiverDefinition = @this.EventReceivers.OfType<SPEventReceiverDefinition>().FirstOrDefault(receiver => receiver.Type == eventReceiverType && receiver.Assembly.Equals(assemblyName) && receiver.Class.Equals(className)); if (eventReceiverDefinition == null) { @this.EventReceivers.Add(eventReceiverType, assemblyName, className); eventReceiverDefinition = @this.EventReceivers.OfType<SPEventReceiverDefinition>().First(receiver => receiver.Type == eventReceiverType && receiver.Assembly.Equals(assemblyName) && receiver.Class.Equals(className)); eventReceiverDefinition.Synchronization = synchronization; eventReceiverDefinition.Update(); Type type = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName)); if (type != null && typeof(StateMachineItemEventReceiverBase).IsAssignableFrom(type) && [email protected](SystemFieldNames.ChangeDetectionFieldName)) { @this.Fields.Add(SystemFieldNames.ChangeDetectionFieldName, SPFieldType.Text, false); @this.Update(); IEnumerable<SPField> changeDetectionFields = @this.Fields.OfType<SPField>().Where(field => SystemFieldNames.ChangeDetectionFieldName.Equals(field.Title)).ToList(); foreach (SPField changeDetectionField in changeDetectionFields) { changeDetectionField.Hidden = true; changeDetectionField.Update(); } @this.Update(); } } }
/// <summary> /// Event Receiver Info (List) /// </summary> /// <param name="list">The list</param> /// <param name="type">The event receiver type</param> /// <param name="syncType">The synchronization type</param> public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType) { this.List = list; this.EventOwner = EventReceiverOwner.List; this.ReceiverType = type; this.SynchronizationType = syncType; }
/// <summary> /// Event Receiver Info (Content Type) /// </summary> /// <param name="contentType">The content type</param> /// <param name="type">The event receiver type</param> /// <param name="syncType">The synchronization type</param> public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType) { this.ContentType = contentType; this.ReceiverType = type; this.EventOwner = EventReceiverOwner.ContentType; this.SynchronizationType = syncType; }
public static void Register(SPList list, SPEventReceiverType eventType, SPEventReceiverSynchronization synchronization, int sequenceNumber, string className) { if (!IsRegistered(list, eventType, className)) { list.ParentWeb.AllowUnsafeUpdates = true; var assemblyName = typeof(IronItemEventReceiver).Assembly.FullName; var typeName = typeof(IronItemEventReceiver).FullName; var receiver = list.EventReceivers.Add(); receiver.Type = eventType; receiver.Assembly = assemblyName; receiver.Synchronization = synchronization; receiver.HostType = SPEventHostType.List; receiver.HostId = list.ID; receiver.Class = typeName; receiver.Name = className; receiver.Data = className; receiver.SequenceNumber = sequenceNumber; receiver.Update(); list.Update(); list.ParentWeb.AllowUnsafeUpdates = false; } }
/// <summary> /// Event Receiver Info (Content Type) /// </summary> /// <param name="contentType">The content type</param> /// <param name="type">The event receiver type</param> /// <param name="syncType">The synchronization type</param> /// <param name="assemblyName">The full name of the Assembly</param> /// <param name="className">The fullname of the Type/Class </param> public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType, string assemblyName, string className) { this.ContentType = contentType; this.ReceiverType = type; this.SynchronizationType = syncType; this.AssemblyName = assemblyName; this.ClassName = className; }
/// <summary> /// Event Receiver Info (List) /// </summary> /// <param name="list">The list</param> /// <param name="type">The event receiver type</param> /// <param name="syncType">The synchronization type</param> /// <param name="assemblyName">The full name of the Assembly</param> /// <param name="className">The fullname of the Type/Class </param> public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType, string assemblyName, string className) { this.List = list; this.ReceiverType = type; this.SynchronizationType = syncType; this.AssemblyName = assemblyName; this.ClassName = className; }
/// <summary> /// Adds the event handler to the content type. /// </summary> /// <param name="contentType">The content type.</param> /// <param name="name">The name of the event.</param> /// <param name="receiver">The type reference of the event receiver class.</param> /// <param name="type">The event receiver type.</param> /// <param name="sequence">The sequence.</param> /// <param name="sync">The synchronization type.</param> public void AddEventHandler( SPContentType contentType, string name, Type receiver, SPEventReceiverType type, int sequence, SPEventReceiverSynchronization sync) { // Guard if (receiver == null) { throw new ArgumentNullException("receiver"); } AddEventHandler(contentType, name, receiver.Assembly.FullName, receiver.FullName, type, sequence, sync); }
public static void Register(this SPEventReceiverDefinitionCollection collection, string name, Type receiverType, SPEventReceiverType actionsToHandle, SPEventReceiverSynchronization synchronization = SPEventReceiverSynchronization.Synchronous, int sequenceNumber = 11000) { SPEventReceiverDefinition receiverDefinition = collection.Cast<SPEventReceiverDefinition>() .SingleOrDefault(receiver => string.Equals(receiver.Name, name)); if (receiverDefinition == null) { receiverDefinition = collection.Add(); receiverDefinition.Name = name; receiverDefinition.Synchronization = synchronization; receiverDefinition.Type = actionsToHandle; receiverDefinition.SequenceNumber = sequenceNumber; receiverDefinition.Assembly = receiverType.Assembly.ToString(); receiverDefinition.Class = receiverType.FullName; receiverDefinition.Update(); } }
public virtual SPEventReceiverDefinition RegisterEventReceiver(SPEventReceiverDefinitionCollection collection, string eventReceiverName, string assembly, string className, SPEventReceiverType type, SPEventReceiverSynchronization sync, int? sequenceNumber) { var result = collection.Add(); result.Name = eventReceiverName; result.Assembly = assembly; result.Class = className; result.Type = type; result.Synchronization = sync; if (sequenceNumber.HasValue) result.SequenceNumber = sequenceNumber.Value; result.Update(); return result; }
public static void Register(SPContentType ct, SPEventReceiverType eventType, SPEventReceiverSynchronization synchronization, int sequenceNumber, string className, bool updateChildren) { if (!IsRegistered(ct, eventType, className)) { ct.ParentWeb.AllowUnsafeUpdates = true; var assemblyName = typeof(IronItemEventReceiver).Assembly.FullName; var typeName = typeof(IronItemEventReceiver).FullName; var receiver = ct.EventReceivers.Add(); receiver.Type = eventType; receiver.Assembly = assemblyName; receiver.Synchronization = synchronization; receiver.Class = typeName; receiver.Name = className; receiver.Data = className; receiver.SequenceNumber = sequenceNumber; receiver.Update(); ct.Update(updateChildren); ct.ParentWeb.AllowUnsafeUpdates = false; } }
public static void EnsureReceiver(SPList list, Type receiverClass, int sequence = 10000, SPEventReceiverSynchronization sync = SPEventReceiverSynchronization.Default, string name = null, params SPEventReceiverType[] receiverTypes) { if (receiverClass == null) { throw new ArgumentNullException(nameof(receiverClass)); } if (name == null) { name = $"Event receiver of type {receiverClass.FullName}"; } foreach (var receiverType in receiverTypes) { var receiverClassName = receiverClass.FullName; var receiverAssembly = receiverClass.Assembly.FullName; var receiver = list.EventReceivers.OfType <SPEventReceiverDefinition>().FirstOrDefault( x => x.Class == receiverClassName && x.Type == receiverType); if (receiver == null) { var rec = list.EventReceivers.Add(); rec.Name = name; rec.Assembly = receiverAssembly; rec.Class = receiverClassName; rec.Synchronization = sync; rec.Type = receiverType; rec.SequenceNumber = sequence; rec.Update(); } } }
private SPEventReceiverDefinition AddEventReceiverDefinition(SPContentType contentType, SPEventReceiverType type, Assembly assembly, string className, SPEventReceiverSynchronization syncType) { SPEventReceiverDefinition eventReceiverDefinition = null; var isAlreadyDefined = contentType.EventReceivers.Cast<SPEventReceiverDefinition>() .Any(x => (x.Class == className) && (x.Type == type)); // If definition isn't already defined, add it to the content type if (!isAlreadyDefined) { eventReceiverDefinition = contentType.EventReceivers.Add(); eventReceiverDefinition.Type = type; eventReceiverDefinition.Assembly = assembly.FullName; eventReceiverDefinition.Synchronization = syncType; eventReceiverDefinition.Class = className; eventReceiverDefinition.Update(); contentType.Update(true); } return eventReceiverDefinition; }
/// <summary> /// Event Receiver Info (List) /// </summary> /// <param name="list">The list</param> /// <param name="type">The event receiver type</param> /// <param name="syncType">The synchronization type</param> public EventReceiverInfo(ListInfo list, SPEventReceiverType type, SPEventReceiverSynchronization syncType) : this(list, type, syncType, string.Empty, string.Empty) { }
private SPEventReceiverDefinition AddEventReceiverDefinition(SPContentType contentType, SPEventReceiverType type, string assemblyName, string className, SPEventReceiverSynchronization syncType) { SPEventReceiverDefinition eventReceiverDefinition = null; var classType = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName)); if (classType != null) { var assembly = Assembly.GetAssembly(classType); eventReceiverDefinition = this.AddEventReceiverDefinition(contentType, type, assembly, className, syncType); } return eventReceiverDefinition; }
private SPEventReceiverDefinition AddEventReceiverDefinition(SPList list, SPEventReceiverType type, string assemblyName, string className, SPEventReceiverSynchronization syncType, int sequenceNumber) { SPEventReceiverDefinition eventReceiverDefinition = null; // Try Parse the Assembly Name var classType = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName)); if (classType != null) { var assembly = Assembly.GetAssembly(classType); var isAlreadyDefined = list.EventReceivers.Cast<SPEventReceiverDefinition>().Any(x => (x.Class == className) && (x.Type == type)); // If definition isn't already defined, add it to the list if (!isAlreadyDefined) { eventReceiverDefinition = list.EventReceivers.Add(); eventReceiverDefinition.Type = type; eventReceiverDefinition.Assembly = assembly.FullName; eventReceiverDefinition.Synchronization = syncType; eventReceiverDefinition.Class = className; eventReceiverDefinition.SequenceNumber = sequenceNumber; eventReceiverDefinition.Update(); list.Update(); } } return eventReceiverDefinition; }
public static void AddEventReceiverToContentType(string className, SPContentType contentType, string assemblyName, SPEventReceiverType eventReceiverType, SPEventReceiverSynchronization eventReceiverSynchronization) { className.RequireNotNullOrEmpty("className"); contentType.RequireNotNull("contentType"); assemblyName.RequireNotNullOrEmpty("assemblyName"); eventReceiverType.RequireNotNull("eventReceiverType"); eventReceiverSynchronization.RequireNotNull("eventReceiverSynchronization"); SPEventReceiverDefinition eventReceiver = contentType.EventReceivers.Add(); eventReceiver.Synchronization = eventReceiverSynchronization; eventReceiver.Type = eventReceiverType; eventReceiver.Assembly = assemblyName; eventReceiver.Class = className; eventReceiver.Update(); }
/// <summary> /// Adds the event handler to the content type. /// </summary> /// <param name="contentType">The content type.</param> /// <param name="name">The name of the event.</param> /// <param name="receiver">The type reference of the event receiver class.</param> /// <param name="type">The event receiver type.</param> /// <param name="sequence">The sequence.</param> /// <param name="sync">The synchronization type.</param> public static void AddEventHandler( SPContentType contentType, string name, Type receiver, SPEventReceiverType type, int sequence, SPEventReceiverSynchronization sync) { // Guard if (receiver == null) { throw new ArgumentNullException("receiver"); } AddEventHandler(contentType, name, receiver.Assembly.FullName, receiver.FullName, type, sequence, sync); }
/// <summary> /// Обеспечить наличие на списке <paramref name="list"/> EventReceiver'а <paramref name="name"/>. /// Этот метод позволяет программно повесить обработчик события на список. /// Если на момент вызова данного метода, такой обработчик на списке уже висел, то он будет повешен заново. /// </summary> /// <param name="name"></param> /// <param name="list"></param> /// <param name="typeClassReceiver"></param> /// <param name="typeReceiver"></param> /// <param name="synchronizationValue"></param> /// <param name="sequenceNumber"></param> public static void ProvisionListEventReceiver(string name, SPList list, Type typeClassReceiver, SPEventReceiverType typeReceiver, SPEventReceiverSynchronization synchronizationValue, int sequenceNumber) { DeleteListEventReceiver(list, typeClassReceiver, typeReceiver); AddListEventReceiver(name, list, typeClassReceiver, typeReceiver, synchronizationValue, sequenceNumber); }
/// <summary> /// Добавить списку <paramref name="list"/> EventReceiver с именем <paramref name="name"/>. /// </summary> /// <param name="name">User friendly name for EventReceiver</param> /// <param name="list">SPList, к которому добавляется EventReceiver </param> /// <param name="typeClassReceiver">Тип (класс), в котором реализован метод-обработчик соответствующего EventReceiver'а</param> /// <param name="typeReceiver">Тип EventReceiver'а. Используйте только типы EventReceiver'ов, которые используются для СПИСКОВ (SPList)</param> /// <param name="synchronizationValue" >Синхронное или Асинхронное</param> /// <param name="sequenceNumber">Число, представляющее место данного события в последовательности событий</param> /// <exception cref="ArgumentNullException">Возникает если следующие параметры равны null: <paramref name="name"/>, <paramref name="list"/>, <paramref name="typeClassReceiver"/>. /// </exception> /// <exception cref="ArgumentException">Возникает если у списка уже есть Event ресивер типа <paramref name="typeReceiver"/> реализованный с помощью класса <paramref name="typeClassReceiver"/> /// </exception> public static void AddListEventReceiver(string name, SPList list, Type typeClassReceiver, SPEventReceiverType typeReceiver, SPEventReceiverSynchronization synchronizationValue, int sequenceNumber) { #region Проверка входящих параметров на null if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException("name"); } if (list == null) { throw new ArgumentNullException("list"); } if (typeClassReceiver == null) { throw new ArgumentNullException("typeClassReceiver"); } #endregion var eventReceiverAssembly = typeClassReceiver.Assembly.FullName; var eventReceiverClass = typeClassReceiver.FullName; #region Проверяем есть ли уже в списке такой Event Reciever. for (var i = 0; i < list.EventReceivers.Count; i++) { var eventReceiverDefinition = list.EventReceivers[i]; if (String.Equals(eventReceiverDefinition.Name, name)) { throw new ArgumentException("Event Receiver с таким именем уже существует.", "name"); } if (eventReceiverDefinition.Assembly == eventReceiverAssembly && eventReceiverDefinition.Class == eventReceiverClass && eventReceiverDefinition.Type == typeReceiver) { throw new ArgumentException( String.Format("Такой Event Receiver уже существует. eventReceiverClass = {0} eventReceiverAssembly = {1}, typeReceiver = {2}", eventReceiverClass, eventReceiverAssembly, typeReceiver)); } } #endregion // Создаём новый EventReceiver SPEventReceiverDefinition newEventReceiverDefinition = list.EventReceivers.Add(); newEventReceiverDefinition.Type = typeReceiver; newEventReceiverDefinition.Assembly = typeClassReceiver.Assembly.FullName; newEventReceiverDefinition.Class = typeClassReceiver.FullName; // Задаём правильное имя EventReceiver'у newEventReceiverDefinition.Name = name; // Задаём тип синхронизации newEventReceiverDefinition.Synchronization = synchronizationValue; newEventReceiverDefinition.SequenceNumber = sequenceNumber; newEventReceiverDefinition.Update(); }
private SPEventReceiverDefinition AddEventReceiverDefinition(SPContentType contentType, SPEventReceiverType type, Assembly assembly, string className, SPEventReceiverSynchronization syncType) { SPEventReceiverDefinition eventReceiverDefinition = null; var isAlreadyDefined = contentType.EventReceivers.Cast <SPEventReceiverDefinition>() .Any(x => (x.Class == className) && (x.Type == type)); // If definition isn't already defined, add it to the content type if (!isAlreadyDefined) { eventReceiverDefinition = contentType.EventReceivers.Add(); eventReceiverDefinition.Type = type; eventReceiverDefinition.Assembly = assembly.FullName; eventReceiverDefinition.Synchronization = syncType; eventReceiverDefinition.Class = className; eventReceiverDefinition.Update(); contentType.Update(true); } return(eventReceiverDefinition); }
public virtual void UpdateEventReceiver(SPEventReceiverDefinition eventReceiver, string eventReceiverName, string assembly, string className, SPEventReceiverType type, SPEventReceiverSynchronization sync, int? sequenceNumber) { eventReceiver.Name = eventReceiverName; eventReceiver.Assembly = assembly; eventReceiver.Class = className; eventReceiver.Synchronization = sync; if (sequenceNumber.HasValue) eventReceiver.SequenceNumber = sequenceNumber.Value; eventReceiver.Update(); }
public SPGENEventHandlerSynchronizationAttribute(SPEventReceiverSynchronization synchronization) { this.Synchronization = synchronization; }
public void RegisterItemEventHandler(ref SPList list, Type receiverClassType, SPEventReceiverType receiverType, int sequence, SPEventReceiverSynchronization sync) { SPEventReceiverDefinition def = GetEventReceiver(ref list, receiverClassType, receiverType); if (def == null) { def = list.EventReceivers.Add(); def.Assembly = receiverClassType.Assembly.FullName; //"ERDefinition, Version=1.0.0.0, Culture=Neutral, PublicKeyToken=704f58d28567dc00"; def.Class = receiverClassType.Name; // "ERDefinition.ItemEvents"; def.Name = receiverClassType.Name + "_" + receiverType.ToString(); //ItemAdded Event"; def.Type = receiverType; } def.SequenceNumber = sequence; def.Synchronization = sync; def.Update(); }
private SPEventReceiverDefinition AddEventReceiverDefinition(SPList list, SPEventReceiverType type, string assemblyName, string className, SPEventReceiverSynchronization syncType, int sequenceNumber) { SPEventReceiverDefinition eventReceiverDefinition = null; // Try Parse the Assembly Name var classType = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName)); if (classType != null) { var assembly = Assembly.GetAssembly(classType); var isAlreadyDefined = list.EventReceivers.Cast <SPEventReceiverDefinition>().Any(x => (x.Class == className) && (x.Type == type)); // If definition isn't already defined, add it to the list if (!isAlreadyDefined) { eventReceiverDefinition = list.EventReceivers.Add(); eventReceiverDefinition.Type = type; eventReceiverDefinition.Assembly = assembly.FullName; eventReceiverDefinition.Synchronization = syncType; eventReceiverDefinition.Class = className; eventReceiverDefinition.SequenceNumber = sequenceNumber; eventReceiverDefinition.Update(); list.Update(); } } return(eventReceiverDefinition); }
public static void EnsureEventReceiver(this SPList list, System.Type ReceiverClass, int sequence, SPEventReceiverSynchronization synchronous, params SPEventReceiverType[] ReceiverTypes) { if (list == null) { return; } try { list.ParentWeb.AllowUnsafeUpdates = true; string assembly = ReceiverClass.Assembly.FullName; foreach (var item in ReceiverTypes) { if (!list.EventReceivers.Cast <SPEventReceiverDefinition>().Any(P => P.Class == ReceiverClass.FullName && P.Assembly == assembly && P.Type == item)) { var def = list.EventReceivers.Add(); def.Assembly = assembly; def.Class = ReceiverClass.FullName; def.Synchronization = synchronous; def.SequenceNumber = sequence; def.Type = ReceiverTypes[0]; foreach (var type in ReceiverTypes) { def.Type |= type; } def.Update(); } } list.Update(); } catch (Exception) { } finally { list.ParentWeb.AllowUnsafeUpdates = false; } }
public static void Register(this SPEventReceiverDefinitionCollection collection, string name, Type receiverType, SPEventReceiverType actionsToHandle, SPEventReceiverSynchronization synchronization = SPEventReceiverSynchronization.Synchronous, int sequenceNumber = 11000) { SPEventReceiverDefinition receiverDefinition = collection.Cast <SPEventReceiverDefinition>() .SingleOrDefault(receiver => string.Equals(receiver.Name, name)); if (receiverDefinition == null) { receiverDefinition = collection.Add(); receiverDefinition.Name = name; receiverDefinition.Synchronization = synchronization; receiverDefinition.Type = actionsToHandle; receiverDefinition.SequenceNumber = sequenceNumber; receiverDefinition.Assembly = receiverType.Assembly.ToString(); receiverDefinition.Class = receiverType.FullName; receiverDefinition.Update(); } }
public static void Register(SPContentType ct, SPEventReceiverType eventType, SPEventReceiverSynchronization synchronization, int sequenceNumber, string className) { Register(ct, eventType, synchronization, sequenceNumber, className, true); }
/// <summary> /// Adds the event handler to the content type. /// </summary> /// <param name="contentType">The content type.</param> /// <param name="name">The name of the event.</param> /// <param name="assembly">The assembly containing the event receiver.</param> /// <param name="className">Name of the event receiver class.</param> /// <param name="type">The event receiver type.</param> /// <param name="sequence">The sequence.</param> /// <param name="sync">The synchronization type.</param> public static void AddEventHandler( SPContentType contentType, string name, string assembly, string className, SPEventReceiverType type, int sequence, SPEventReceiverSynchronization sync) { // Guard if (contentType == null) { throw new ArgumentNullException("contentType"); } SPEventReceiverDefinition definition = GetEventHandler(contentType.EventReceivers, name, type); if (definition == null) { contentType.EventReceivers.Add(type, assembly, className); definition = GetEventHandler(contentType.EventReceivers, className, type); } definition.Name = name; definition.SequenceNumber = sequence; definition.Synchronization = sync; definition.Update(); }
/// <summary> /// Event Receiver Info (Content Type) /// </summary> /// <param name="contentType">The content type</param> /// <param name="type">The event receiver type</param> /// <param name="syncType">The synchronization type</param> public EventReceiverInfo(ContentTypeInfo contentType, SPEventReceiverType type, SPEventReceiverSynchronization syncType) : this(contentType, type, syncType, string.Empty, string.Empty) { }
private SPEventReceiverDefinition AddEventReceiverDefinition(SPContentType contentType, SPEventReceiverType type, string assemblyName, string className, SPEventReceiverSynchronization syncType) { SPEventReceiverDefinition eventReceiverDefinition = null; var classType = Type.GetType(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", className, assemblyName)); if (classType != null) { var assembly = Assembly.GetAssembly(classType); eventReceiverDefinition = this.AddEventReceiverDefinition(contentType, type, assembly, className, syncType); } return(eventReceiverDefinition); }