//-----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation.
//
//-----------------------------------------------------------------------
namespace Microsoft.Isam.Esent.Interop
{
using System;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
///
/// A JET_INSTANCE contains a handle to the instance of the database to use for calls to the JET Api.
///
public struct JET_INSTANCE : IEquatable, IFormattable
{
///
/// The native value.
///
internal IntPtr Value;
///
/// Gets a null JET_INSTANCE.
///
public static JET_INSTANCE Nil
{
[DebuggerStepThrough]
get { return new JET_INSTANCE(); }
}
///
/// Gets a value indicating whether the is valid (checks against 0 and -1).
///
public bool IsInvalid
{
get { return this.Value == IntPtr.Zero || this.Value == new IntPtr(~0); }
}
///
/// Determines whether two specified instances of JET_INSTANCE
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_INSTANCE lhs, JET_INSTANCE rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_INSTANCE
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_INSTANCE lhs, JET_INSTANCE rhs)
{
return !(lhs == rhs);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_INSTANCE(0x{0:x})", this.Value.ToInt64());
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToInt64().ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_INSTANCE)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_INSTANCE other)
{
return this.Value.Equals(other.Value);
}
}
///
/// A JET_SESID contains a handle to the session to use for calls to the JET Api.
///
public struct JET_SESID : IEquatable, IFormattable
{
///
/// The native value.
///
internal IntPtr Value;
///
/// Gets a null JET_SESID.
///
public static JET_SESID Nil
{
[DebuggerStepThrough]
get { return new JET_SESID(); }
}
///
/// Gets a value indicating whether the is valid (checks against 0 and -1).
///
public bool IsInvalid
{
get { return this.Value == IntPtr.Zero || this.Value == new IntPtr(~0); }
}
///
/// Determines whether two specified instances of JET_SESID
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_SESID lhs, JET_SESID rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_SESID
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_SESID lhs, JET_SESID rhs)
{
return !(lhs == rhs);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_SESID(0x{0:x})", this.Value.ToInt64());
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToInt64().ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_SESID)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_SESID other)
{
return this.Value.Equals(other.Value);
}
}
///
/// A JET_TABLEID contains a handle to the database cursor to use for a call to the JET Api.
/// A cursor can only be used with the session that was used to open that cursor.
///
public struct JET_TABLEID : IEquatable, IFormattable
{
///
/// The native value.
///
internal IntPtr Value;
///
/// Gets a null JET_TABLEID.
///
public static JET_TABLEID Nil
{
[DebuggerStepThrough]
get { return new JET_TABLEID(); }
}
///
/// Gets a value indicating whether the is valid (checks against 0 and -1).
///
public bool IsInvalid
{
get { return this.Value == IntPtr.Zero || this.Value == new IntPtr(~0); }
}
///
/// Determines whether two specified instances of JET_TABLEID
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_TABLEID lhs, JET_TABLEID rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_TABLEID
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_TABLEID lhs, JET_TABLEID rhs)
{
return !(lhs == rhs);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_TABLEID(0x{0:x})", this.Value.ToInt64());
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToInt64().ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_TABLEID)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_TABLEID other)
{
return this.Value.Equals(other.Value);
}
}
///
/// A JET_DBID contains the handle to the database. A database handle is used to manage the
/// schema of a database. It can also be used to manage the tables inside of that database.
///
public struct JET_DBID : IEquatable, IFormattable
{
///
/// The native value.
///
internal uint Value;
///
/// Gets a null JET_DBID.
///
public static JET_DBID Nil
{
get
{
return new JET_DBID { Value = 0xffffffff };
}
}
///
/// Determines whether two specified instances of JET_DBID
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_DBID lhs, JET_DBID rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_DBID
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_DBID lhs, JET_DBID rhs)
{
return !(lhs == rhs);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_DBID({0})", this.Value);
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_DBID)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_DBID other)
{
return this.Value.Equals(other.Value);
}
}
///
/// A JET_COLUMNID identifies a column within a table.
///
public struct JET_COLUMNID : IEquatable, IComparable, IFormattable
{
///
/// The native value.
///
internal uint Value;
///
/// Gets a null JET_COLUMNID.
///
public static JET_COLUMNID Nil
{
[DebuggerStepThrough]
get { return new JET_COLUMNID(); }
}
///
/// Gets a value indicating whether the is valid (checks against 0 and -1).
///
public bool IsInvalid
{
get { return this.Value == 0 || this.Value == 0xffffffff; }
}
///
/// Determines whether two specified instances of JET_COLUMNID
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_COLUMNID lhs, JET_COLUMNID rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_COLUMNID
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_COLUMNID lhs, JET_COLUMNID rhs)
{
return !(lhs == rhs);
}
///
/// Determine whether one columnid is before another columnid.
///
/// The first columnid to compare.
/// The second columnid to compare.
/// True if lhs comes before rhs.
public static bool operator <(JET_COLUMNID lhs, JET_COLUMNID rhs)
{
return lhs.Value < rhs.Value;
}
///
/// Determine whether one columnid is after another columnid.
///
/// The first columnid to compare.
/// The second columnid to compare.
/// True if lhs comes after rhs.
public static bool operator >(JET_COLUMNID lhs, JET_COLUMNID rhs)
{
return lhs.Value > rhs.Value;
}
///
/// Determine whether one columnid is before or equal to
/// another columnid.
///
/// The first columnid to compare.
/// The second columnid to compare.
/// True if lhs comes before or is equal to rhs.
public static bool operator <=(JET_COLUMNID lhs, JET_COLUMNID rhs)
{
return lhs.Value <= rhs.Value;
}
///
/// Determine whether one columnid is after or equal to
/// another columnid.
///
/// The first columnid to compare.
/// The second columnid to compare.
/// True if lhs comes after or is equal to rhs.
public static bool operator >=(JET_COLUMNID lhs, JET_COLUMNID rhs)
{
return lhs.Value >= rhs.Value;
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_COLUMNID(0x{0:x})", this.Value);
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_COLUMNID)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_COLUMNID other)
{
return this.Value.Equals(other.Value);
}
///
/// Compares this columnid to another columnid and determines
/// whether this instance is before, the same as or after the other
/// instance.
///
/// The columnid to compare to the current instance.
///
/// A signed number indicating the relative positions of this instance and the value parameter.
///
public int CompareTo(JET_COLUMNID other)
{
return this.Value.CompareTo(other.Value);
}
///
/// Creates a new instance of a using the specified
/// value as the underlying value.
///
/// The native ESE JET_COLUMNID.
/// An initialized structure.
/// Use of this function should be exceedingly rare.
internal static JET_COLUMNID CreateColumnidFromNativeValue(int nativeValue)
{
return new JET_COLUMNID()
{
Value = unchecked((uint)nativeValue)
};
}
}
#if !MANAGEDESENT_ON_WSA // Not exposed in MSDK
///
/// A JET_OSSNAPID contains a handle to a snapshot of a database.
///
public struct JET_OSSNAPID : IEquatable, IFormattable
{
///
/// The native value.
///
internal IntPtr Value;
///
/// Gets a null JET_OSSNAPID.
///
public static JET_OSSNAPID Nil
{
[DebuggerStepThrough]
get { return new JET_OSSNAPID(); }
}
///
/// Gets a value indicating whether the is valid (checks against 0 and -1).
///
public bool IsInvalid
{
get { return this.Value == IntPtr.Zero || this.Value == new IntPtr(~0); }
}
///
/// Determines whether two specified instances of JET_OSSNAPID
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_OSSNAPID lhs, JET_OSSNAPID rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_OSSNAPID
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_OSSNAPID lhs, JET_OSSNAPID rhs)
{
return !(lhs == rhs);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_OSSNAPID(0x{0:x})", this.Value.ToInt64());
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToInt64().ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_OSSNAPID)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_OSSNAPID other)
{
return this.Value.Equals(other.Value);
}
}
#endif // !MANAGEDESENT_ON_WSA
///
/// A JET_HANDLE contains a generic handle.
///
public struct JET_HANDLE : IEquatable, IFormattable
{
///
/// The native value.
///
internal IntPtr Value;
///
/// Gets a null JET_HANDLE.
///
public static JET_HANDLE Nil
{
[DebuggerStepThrough]
get { return new JET_HANDLE(); }
}
///
/// Gets a value indicating whether the is valid (checks against 0 and -1).
///
public bool IsInvalid
{
get { return this.Value == IntPtr.Zero || this.Value == new IntPtr(~0); }
}
///
/// Determines whether two specified instances of JET_HANDLE
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_HANDLE lhs, JET_HANDLE rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_HANDLE
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_HANDLE lhs, JET_HANDLE rhs)
{
return !(lhs == rhs);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_HANDLE(0x{0:x})", this.Value.ToInt64());
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToInt64().ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_HANDLE)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_HANDLE other)
{
return this.Value.Equals(other.Value);
}
}
#if !MANAGEDESENT_ON_WSA
///
/// Local storage for an ESENT handle. Used by
/// and .
///
public struct JET_LS : IEquatable, IFormattable
{
///
/// The null handle.
///
public static readonly JET_LS Nil = new JET_LS { Value = new IntPtr(~0) };
///
/// Gets a value indicating whether the is valid (checks against 0 and -1).
///
public bool IsInvalid
{
get { return this.Value == IntPtr.Zero || this.Value == new IntPtr(~0); }
}
///
/// Gets or sets the value of the handle.
///
public IntPtr Value { get; set; }
///
/// Determines whether two specified instances of JET_LS
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_LS lhs, JET_LS rhs)
{
return lhs.Value == rhs.Value;
}
///
/// Determines whether two specified instances of JET_LS
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_LS lhs, JET_LS rhs)
{
return !(lhs == rhs);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "JET_LS(0x{0:x})", this.Value.ToInt64());
}
///
/// Formats the value of the current instance using the specified format.
///
///
/// A containing the value of the current instance in the specified format.
///
/// The specifying the format to use.
/// -or-
/// null to use the default format defined for the type of the implementation.
///
/// The to use to format the value.
/// -or-
/// null to obtain the numeric format information from the current locale setting of the operating system.
///
public string ToString(string format, IFormatProvider formatProvider)
{
return string.IsNullOrEmpty(format) || "G" == format ? this.ToString() : this.Value.ToInt64().ToString(format, formatProvider);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_LS)obj);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.Value.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_LS other)
{
return this.Value.Equals(other.Value);
}
}
#endif // !MANAGEDESENT_ON_WSA
///
/// Holds an index ID. An index ID is a hint that is used to accelerate the
/// selection of the current index using JetSetCurrentIndex. It is most
/// useful when there is a very large number of indexes over a table. The
/// index ID can be retrieved using JetGetIndexInfo or JetGetTableIndexInfo.
///
///
/// The Pack attribute is necessary because the C++ version is defined as
/// a byte array. If the C# compiler inserts the usual padding between the uint cbStruct
/// and the IntPtr, then the structure ends up too large.
///
[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct JET_INDEXID : IEquatable
{
///
/// Size of the structure.
///
internal uint CbStruct;
///
/// Internal use only.
///
internal IntPtr IndexId1;
///
/// Internal use only.
///
internal uint IndexId2;
///
/// Internal use only.
///
internal uint IndexId3;
///
/// The size of a JET_INDEXID structure.
///
private static readonly uint TheSizeOfIndexId = (uint)Marshal.SizeOf(typeof(JET_INDEXID));
///
/// Gets the size of a JET_INDEXINDEXID structure.
///
internal static uint SizeOfIndexId
{
[DebuggerStepThrough]
get { return TheSizeOfIndexId; }
}
///
/// Determines whether two specified instances of JET_INDEXID
/// are equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are equal.
public static bool operator ==(JET_INDEXID lhs, JET_INDEXID rhs)
{
return lhs.Equals(rhs);
}
///
/// Determines whether two specified instances of JET_INDEXID
/// are not equal.
///
/// The first instance to compare.
/// The second instance to compare.
/// True if the two instances are not equal.
public static bool operator !=(JET_INDEXID lhs, JET_INDEXID rhs)
{
return !(lhs == rhs);
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An object to compare with this instance.
/// True if the two instances are equal.
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return this.Equals((JET_INDEXID)obj);
}
///
/// Generate a string representation of the structure.
///
/// The structure as a string.
public override string ToString()
{
return string.Format(
CultureInfo.InvariantCulture,
"JET_INDEXID(0x{0:x}:0x{1:x}:0x{2:x})",
this.IndexId1,
this.IndexId2,
this.IndexId3);
}
///
/// Returns the hash code for this instance.
///
/// The hash code for this instance.
public override int GetHashCode()
{
return this.CbStruct.GetHashCode()
^ this.IndexId1.GetHashCode()
^ this.IndexId2.GetHashCode()
^ this.IndexId3.GetHashCode();
}
///
/// Returns a value indicating whether this instance is equal
/// to another instance.
///
/// An instance to compare with this instance.
/// True if the two instances are equal.
public bool Equals(JET_INDEXID other)
{
return this.CbStruct == other.CbStruct
&& this.IndexId1 == other.IndexId1
&& this.IndexId2 == other.IndexId2
&& this.IndexId3 == other.IndexId3;
}
}
}