// -----------------------------------------------------------------------------------
public OpcEnumItemAttributes CreateAttrEnumerator()
{
Type typEnuAtt = typeof(IEnumOPCItemAttributes);
Guid guidEnuAtt = typEnuAtt.GUID;
object objtemp;
int hresult = ifItems.CreateEnumerator(ref guidEnuAtt, out objtemp);
if (HRESULTS.Failed(hresult))
{
Marshal.ThrowExceptionForHR(hresult);
}
if ((hresult == HRESULTS.S_FALSE) || (objtemp == null))
{
return(null);
}
IEnumOPCItemAttributes ifenu = (IEnumOPCItemAttributes)objtemp;
objtemp = null;
OpcEnumItemAttributes enu = new OpcEnumItemAttributes(ifenu);
return(enu);
}
public void Dispose()
{
if (this.ifEnum != null)
{
int num = Marshal.ReleaseComObject(this.ifEnum);
this.ifEnum = null;
}
}
public void Dispose()
{
if (m_IfEnum != null)
{
Marshal.ReleaseComObject(m_IfEnum);
m_IfEnum = null;
}
}
/// <summary>
/// Dispose
/// </summary>
private void ReleaseComObject()
{
if (enumItemAttributes != null)
{
Marshal.ReleaseComObject(enumItemAttributes);
}
enumItemAttributes = null;
}
/// <summary>
/// Synchronizes the group items. It means existing items will be replaced with new items. It fires ItemsChanged event
/// after synchronization.
/// </summary>
public void SyncItems()
{
IEnumOPCItemAttributes enumerator = As <OpcItemMgt>().CreateEnumerator();
List <OPCITEMATTRIBUTES> itemAttributes = enumerator.EnumareateAllAndRelease(OpcConfiguration.BatchSize);
OpcDaItem[] oldItems = _items.ToArray();
_items.Clear();
foreach (OPCITEMATTRIBUTES opcitemattributes in itemAttributes)
{
var item = new OpcDaItem(opcitemattributes, this);
_items.Add(item);
}
OnItemsChanged(new OpcDaItemsChangedEventArgs(_items.ToArray(), oldItems, null));
}
public void Clone(out IEnumOPCItemAttributes ppEnumItemAttributes)
{
lock (this)
{
try
{
ppEnumItemAttributes = new EnumOPCItemAttributes(m_items);
}
catch (Exception e)
{
throw Server.CreateException(e);
}
}
}
/// <remarks/>
public void Clone(out IEnumOPCItemAttributes ppEnumItemAttributes)
{
lock (m_lock)
{
try
{
ppEnumItemAttributes = new EnumOPCItemAttributes(m_items);
}
catch (Exception e)
{
throw ComUtils.CreateComException(e);
}
}
}
public static List <OPCITEMATTRIBUTES> EnumareateAllAndRelease(this IEnumOPCItemAttributes enumerator,
int requestSize = 128)
{
try
{
return(EnumerateAll(enumerator, requestSize));
}
finally
{
if (enumerator != null)
{
Marshal.ReleaseComObject(enumerator);
}
}
}
public void Clone(out IEnumOPCItemAttributes ppEnumItemAttributes)
{
EnumOPCItemAttributes attributes;
Monitor.Enter(attributes = this);
try
{
ppEnumItemAttributes = new EnumOPCItemAttributes(this.m_items);
}
catch (Exception exception)
{
throw OpcCom.Da.Wrapper.Server.CreateException(exception);
}
finally
{
Monitor.Exit(attributes);
}
}
public OpcEnumItemAttributes CreateAttrEnumerator()
{
object obj2;
Type type = typeof(IEnumOPCItemAttributes);
Guid gUID = type.GUID;
int hresultcode = this.ifItems.CreateEnumerator(ref gUID, out obj2);
if (HRESULTS.Failed(hresultcode))
{
Marshal.ThrowExceptionForHR(hresultcode);
}
if ((hresultcode == 1) || (obj2 == null))
{
return(null);
}
IEnumOPCItemAttributes ifEnump = (IEnumOPCItemAttributes)obj2;
obj2 = null;
return(new OpcEnumItemAttributes(ifEnump));
}
public OPCEnumItemAttributes CreateAttrEnumerator()
{
Type l_TypEnuAtt = typeof(IEnumOPCItemAttributes);
Guid l_GuidEnuAtt = l_TypEnuAtt.GUID;
object l_ObjTemp;
int l_HResult = m_IfItems.CreateEnumerator(ref l_GuidEnuAtt, out l_ObjTemp);
if (HResults.Failed(l_HResult))
{
Marshal.ThrowExceptionForHR(l_HResult);
}
if ((l_HResult == HResults.S_FALSE) || (l_ObjTemp == null))
{
return(null);
}
IEnumOPCItemAttributes l_IfEnu = (IEnumOPCItemAttributes)l_ObjTemp;
l_ObjTemp = null;
OPCEnumItemAttributes l_Enu = new OPCEnumItemAttributes(l_IfEnu);
return(l_Enu);
}
public static List <OPCITEMATTRIBUTES> EnumerateAll(this IEnumOPCItemAttributes enumerator, int requestSize = 128)
{
if (enumerator == null)
{
return(new List <OPCITEMATTRIBUTES>());
}
var result = new List <OPCITEMATTRIBUTES>();
var fetched = 0;
do
{
IntPtr ptr;
enumerator.Next(requestSize, out ptr, out fetched);
for (var i = 0; i < fetched; i++)
{
var current = ptr + i * Marshal.SizeOf(typeof(OPCITEMATTRIBUTES));
result.Add((OPCITEMATTRIBUTES)Marshal.PtrToStructure(current, typeof(OPCITEMATTRIBUTES)));
Marshal.DestroyStructure(current, typeof(OPCITEMATTRIBUTES));
}
Marshal.FreeCoTaskMem(ptr);
} while (fetched != 0);
return(result);
}
public void Dispose()
{
if( ! (ifEnum == null) )
{
int rc = Marshal.ReleaseComObject( ifEnum );
ifEnum = null;
}
}
/// <summary>
/// Create OPC enum item attributes enumerator
/// </summary>
/// <param name="enumItemAttributes">If enump</param>
internal OpcEnumItemAttributes(IEnumOPCItemAttributes enumItemAttributes)
{
this.enumItemAttributes = enumItemAttributes;
Current = null;
}
internal OPCEnumItemAttributes(IEnumOPCItemAttributes p_IfEnum)
{
m_IfEnum = p_IfEnum;
}
internal OpcEnumItemAttributes(IEnumOPCItemAttributes ifEnump)
{
this.ifEnum = ifEnump;
}
internal OpcEnumItemAttributes( IEnumOPCItemAttributes ifEnump )
{
ifEnum = ifEnump;
}
/// <remarks/>
public void Clone(out IEnumOPCItemAttributes ppEnumItemAttributes)
{
lock (m_lock)
{
try
{
ppEnumItemAttributes = new EnumOPCItemAttributes(m_items);
}
catch (Exception e)
{
throw ComUtils.CreateComException(e);
}
}
}
