System.Convert.ToInt64(ulong)

Here are the examples of the csharp api System.Convert.ToInt64(ulong) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

20 Examples 7

19 Source : MongoDbRequesterService.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public async Task RemoveAlreadyIncludedTransactionsDBAsync(string databaseName, ulong lastIncludedTransactionSequenceNumber)
        {
            databaseName = ClearSpecialCharacters(databaseName);
            using (IClientSession session = await MongoClient.StartSessionAsync())
            {
                var sidechainDatabase = MongoClient.GetDatabase(_dbPrefix + databaseName);
                var transactionscol = sidechainDatabase.GetCollection<TransactionDB>(MongoDbConstants.REQUESTER_TRANSACTIONS_COLLECTION_NAME);
                var transactionQuery = from t in transactionscol.AsQueryable()
                                       where t.SequenceNumber <= Convert.ToInt64(lastIncludedTransactionSequenceNumber)
                                       select t;
                var waitingTransactionscol = sidechainDatabase.GetCollection<TransactionDB>(MongoDbConstants.REQUESTER_WAITING_FOR_IRREVERSIBILITY_TRANSACTIONS_COLLECTION_NAME);
                var transactionsToRemove = await transactionQuery.ToListAsync();
                if (transactionsToRemove.Any()) await waitingTransactionscol.InsertManyAsync(transactionsToRemove);
                await transactionscol.DeleteManyAsync(t => t.SequenceNumber <= Convert.ToInt64(lastIncludedTransactionSequenceNumber));
            }
        }

19 Source : MongoDbRequesterService.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public async Task<IList<Transaction>> RollbackAndRetrieveWaitingTransactions(string databaseName, ulong lastIncludedTransactionSequenceNumber)
        {
            databaseName = ClearSpecialCharacters(databaseName);
            using (IClientSession session = await MongoClient.StartSessionAsync())
            {
                var sidechainDatabase = MongoClient.GetDatabase(_dbPrefix + databaseName);
                var waitingTransactionscol = sidechainDatabase.GetCollection<TransactionDB>(MongoDbConstants.REQUESTER_WAITING_FOR_IRREVERSIBILITY_TRANSACTIONS_COLLECTION_NAME);
                var transactionQuery = from t in waitingTransactionscol.AsQueryable()
                                       where t.SequenceNumber > Convert.ToInt64(lastIncludedTransactionSequenceNumber)
                                       select t;
                var transactionToSend = sidechainDatabase.GetCollection<TransactionDB>(MongoDbConstants.REQUESTER_TRANSACTIONS_COLLECTION_NAME);
                var transactionsToRetrieve = await transactionQuery.ToListAsync();
                if (transactionsToRetrieve.Any()) await transactionToSend.InsertManyAsync(transactionsToRetrieve);
                await waitingTransactionscol.DeleteManyAsync(t => t.SequenceNumber > Convert.ToInt64(lastIncludedTransactionSequenceNumber));
                return transactionsToRetrieve.Select(t => t.TransactionFromTransactionDB()).ToList();
            }
        }

19 Source : MongoDbProducerService.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public async Task<IList<Transaction>> GetTransactionsSinceSequenceNumber(string databaseName, ulong transactionNumber)
        {
            databaseName = ClearSpecialCharacters(databaseName);
            using (IClientSession session = await MongoClient.StartSessionAsync())
            {
                var sidechainDatabase = MongoClient.GetDatabase(_dbPrefix + databaseName);

                var transactionCollection = sidechainDatabase.GetCollection<TransactionDB>(MongoDbConstants.PROVIDER_TRANSACTIONS_COLLECTION_NAME);

                var transactionQuery = from t in transactionCollection.AsQueryable()
                                       where t.SequenceNumber > Convert.ToInt64(transactionNumber)
                                       select t;

                return (await transactionQuery.ToListAsync()).Select(t => t.TransactionFromTransactionDB()).ToList();
            }
        }

19 Source : MongoDbProducerService.cs
with GNU Affero General Public License v3.0
from blockbasenetwork

public async Task<Transaction> GetTransactionBySequenceNumber(string databaseName, ulong transactionNumber)
        {
            databaseName = ClearSpecialCharacters(databaseName);
            using (IClientSession session = await MongoClient.StartSessionAsync())
            {
                var sidechainDatabase = MongoClient.GetDatabase(_dbPrefix + databaseName);

                var transactionCollection = sidechainDatabase.GetCollection<TransactionDB>(MongoDbConstants.PROVIDER_TRANSACTIONS_COLLECTION_NAME);

                var transactionQuery = from t in transactionCollection.AsQueryable()
                                       where t.SequenceNumber == Convert.ToInt64(transactionNumber)
                                       select t;

                return (await transactionQuery.ToListAsync()).Select(t => t.TransactionFromTransactionDB()).SingleOrDefault();
            }
        }

19 Source : BasicConvert.Overload.cs
with MIT License
from Dogwei

long IXConverter<ulong, long>.Convert(ulong value)
			=> Convert.ToInt64(value);

19 Source : FileCopier.cs
with Apache License 2.0
from LePopal

public long FreeSpace()
        {
            ulong FreeBytesAvailable;
            ulong TotalNumberOfBytes;
            ulong TotalNumberOfFreeBytes;

            bool success = GetDiskFreeSpaceEx(DestinationFolder,
                                              out FreeBytesAvailable,
                                              out TotalNumberOfBytes,
                                              out TotalNumberOfFreeBytes);
            if (!success)
                throw new System.ComponentModel.Win32Exception();
            return Convert.ToInt64(FreeBytesAvailable);
        }

19 Source : DataExtraction.cs
with MIT License
from mahalex

private static long[] UlongToInt64(ulong[] source)
        {
            var result = new long[source.Length];
            for (var i = 0; i < source.Length; i++)
            {
                result[i] = Convert.ToInt64(source[i]);
            }

            return result;
        }

19 Source : UInt64Extensions.cs
with GNU General Public License v3.0
from ME3Tweaks

public static long ToInt64(this ulong value)
		{
			return Convert.ToInt64(value);
		}

19 Source : BitStream.cs
with MIT License
from MeadowSuite

public long ReadInt64(int bitCount)
        {
            // Read an unsigned long and convert it to a signed long.
            return Convert.ToInt64(ReadUInt64(bitCount));
        }

19 Source : Bytes.cs
with MIT License
from microsoft

long IConvertible.ToInt64(IFormatProvider provider)
        {
            return Convert.ToInt64(this.bytes);
        }

19 Source : Bitwise.cs
with MIT License
from microsoft

static long ParityFunc(long val)
            {
                // parity function using idea described at http://graphics.stanford.edu/~seander/bithacks.html#ParityMultiply
                ulong v = System.Convert.ToUInt64(val);
                v ^= v >> 1;
                v ^= v >> 2;
                v = (v & 0x1111111111111111UL) * 0x1111111111111111UL;
                return System.Convert.ToInt64((v >> 60) & 1);
            }

19 Source : Bitwise.cs
with MIT License
from microsoft

static long ZBitsFunc(IQArray<Pauli> pauli)
            {
                if (pauli.Length > 63) { throw new ExecutionFailException("Cannot pack Z bits of Pauli array longer than 63"); }
                ulong res = 0;
                for (long i = pauli.Length - 1; i >= 0; --i)
                {
                    res <<= 1;
                    if (pauli[i] == Pauli.PauliZ || pauli[i] == Pauli.PauliY)
                    {
                        res |= 1;
                    }
                }
                return System.Convert.ToInt64(res);
            }

19 Source : Bitwise.cs
with MIT License
from microsoft

static long XBitsFunc(IQArray<Pauli> pauli)
            {
                if (pauli.Length > 63) { throw new ExecutionFailException("Cannot pack X bits of Pauli array longer than 63"); }
                ulong res = 0;
                for (long i = pauli.Length - 1; i >= 0; --i)
                {
                    res <<= 1;
                    if (pauli[i] == Pauli.PauliX || pauli[i] == Pauli.PauliY)
                    {
                        res |= 1;
                    }
                }
                return System.Convert.ToInt64(res);
            }

19 Source : UInt64.cs
with MIT License
from Nucs

public override void Emit(FleeILGenerator ilg, IServiceProvider services) {
            EmitLoad(Convert.ToInt64(_myValue), ilg);
        }

19 Source : MDS_Format.cs
with MIT License
from redscientistlabs

public AFile Parse(Stream stream)
        {
            EndianBitConverter bc = EndianBitConverter.CreateForLittleEndian();
            EndianBitConverter bcBig = EndianBitConverter.CreateForBigEndian();
            bool isDvd = false;

            AFile aFile = new AFile();

            aFile.MDSPath = (stream as FileStream).Name;

            stream.Seek(0, SeekOrigin.Begin);

            // check whether the header in the mds file is long enough
            if (stream.Length < 88) throw new MDSParseException("Malformed MDS format: The descriptor file does not appear to be long enough.");

            // parse header
            aFile.Header = aFile.Header.Parse(stream);

            // check version to make sure this is only v1.x
            // currently NO support for version 2.x

            if (aFile.Header.Version[0] > 1)
            {
                throw new MDSParseException($"MDS Parse Error: Only MDS version 1.x is supported!\nDetected version: {aFile.Header.Version[0]}.{aFile.Header.Version[1]}");
            }

            // parse sessions
            Dictionary<int, ASession> aSessions = new Dictionary<int, ASession>();

            stream.Seek(aFile.Header.SessionOffset, SeekOrigin.Begin);
            for (int se = 0; se < aFile.Header.SessionCount; se++)
            {
                byte[] sessionHeader = new byte[24];
                stream.Read(sessionHeader, 0, 24);
                //sessionHeader.Reverse().ToArray();

                ASession session = new ASession();

                session.SessionStart = bc.ToInt32(sessionHeader.Take(4).ToArray());
                session.SessionEnd = bc.ToInt32(sessionHeader.Skip(4).Take(4).ToArray());
                session.SessionNumber = bc.ToInt16(sessionHeader.Skip(8).Take(2).ToArray());
                session.AllBlocks = sessionHeader[10];
                session.NonTrackBlocks = sessionHeader[11];
                session.FirstTrack = bc.ToInt16(sessionHeader.Skip(12).Take(2).ToArray());
                session.LastTrack = bc.ToInt16(sessionHeader.Skip(14).Take(2).ToArray());
                session.TrackOffset = bc.ToInt32(sessionHeader.Skip(20).Take(4).ToArray());


                //mdsf.Sessions.Add(session);
                aSessions.Add(session.SessionNumber, session);
            }

            long footerOffset = 0;

            // parse track blocks
            Dictionary<int, ATrack> aTracks = new Dictionary<int, ATrack>();

            // iterate through each session block
            foreach (ASession session in aSessions.Values)
            {
                stream.Seek(session.TrackOffset, SeekOrigin.Begin);
                //Dictionary<int, ATrack> sessionToc = new Dictionary<int, ATrack>();

                // iterate through every block specified in each session
                for (int bl = 0; bl < session.AllBlocks; bl++)
                {
                    byte[] trackHeader;
                    ATrack track = new ATrack();

                    trackHeader = new byte[80];

                    stream.Read(trackHeader, 0, 80);

                    track.Mode = trackHeader[0];
                    track.SubMode = trackHeader[1];
                    track.ADR_Control = trackHeader[2];
                    track.TrackNo = trackHeader[3];
                    track.Point = trackHeader[4];
                    track.AMin = trackHeader[5];
                    track.ASec = trackHeader[6];
                    track.AFrame = trackHeader[7];
                    track.Zero = trackHeader[8];
                    track.PMin = trackHeader[9];
                    track.PSec = trackHeader[10];
                    track.PFrame = trackHeader[11];
                    track.ExtraOffset = bc.ToInt32(trackHeader.Skip(12).Take(4).ToArray());
                    track.SectorSize = bc.ToInt16(trackHeader.Skip(16).Take(2).ToArray());
                    track.PLBA = bc.ToInt32(trackHeader.Skip(36).Take(4).ToArray());
                    track.StartOffset = BitConverter.ToUInt64(trackHeader.Skip(40).Take(8).ToArray(), 0);
                    track.Files = bc.ToInt32(trackHeader.Skip(48).Take(4).ToArray());
                    track.FooterOffset = bc.ToInt32(trackHeader.Skip(52).Take(4).ToArray());

                    if (track.Mode == 0x02)
                    {
                        isDvd = true;
                        throw new MDSParseException("DVD Detected. Not currently supported!");
                    }
                        

                    // check for track extra block - this can probably be handled in a separate loop,
                    // but I'll just store the current stream position then seek forward to the extra block for this track
                    Int64 currPos = stream.Position;

                    // Only CDs have extra blocks - for DVDs ExtraOffset = track length
                    if (track.ExtraOffset > 0 && !isDvd)
                    {
                        byte[] extHeader = new byte[8];
                        stream.Seek(track.ExtraOffset, SeekOrigin.Begin);
                        stream.Read(extHeader, 0, 8);
                        track.ExtraBlock.Pregap = bc.ToInt32(extHeader.Take(4).ToArray());
                        track.ExtraBlock.Sectors = bc.ToInt32(extHeader.Skip(4).Take(4).ToArray());
                        stream.Seek(currPos, SeekOrigin.Begin);
                    }
                    else if (isDvd == true)
                    {
                        track.ExtraBlock.Sectors = track.ExtraOffset;
                    }

                    // read the footer/filename block for this track
                    currPos = stream.Position;
                    long numOfFilenames = track.Files;
                    for (long fi = 1; fi <= numOfFilenames; fi++)
                    {
                        // skip leadin/out info tracks
                        if (track.FooterOffset == 0)
                            continue;

                        byte[] foot = new byte[16];
                        stream.Seek(track.FooterOffset, SeekOrigin.Begin);
                        stream.Read(foot, 0, 16);

                        AFooter f = new AFooter();
                        f.FilenameOffset = bc.ToInt32(foot.Take(4).ToArray());
                        f.WideChar = bc.ToInt32(foot.Skip(4).Take(4).ToArray());
                        track.FooterBlocks.Add(f);
                        track.FooterBlocks = track.FooterBlocks.Distinct().ToList();

                        // parse the filename string
                        string fileName = "*.mdf";
                        if (f.FilenameOffset > 0)
                        {
                            // filename offset is present
                            stream.Seek(f.FilenameOffset, SeekOrigin.Begin);
                            byte[] fname;

                            if (numOfFilenames == 1)
                            {
                                if (aFile.Header.DPMOffset == 0)
                                {
                                    // filename is in the remaining space to EOF
                                    fname = new byte[stream.Length - stream.Position];
                                }
                                else
                                {
                                    // filename is in the remaining space to EOF + dpm offset
                                    fname = new byte[aFile.Header.DPMOffset - stream.Position];
                                }
                            }

                            else
                            {
                                // looks like each filename string is 6 bytes with a trailing \0
                                fname = new byte[6];
                            }
                            

                            // read the filename
                            stream.Read(fname, 0, fname.Length);

                            // if widechar is 1 filename is stored using 16-bit, otherwise 8-bit is used
                            if (f.WideChar == 1)
                                fileName = Encoding.Unicode.GetString(fname).TrimEnd('\0');
                            else
                                fileName = Encoding.Default.GetString(fname).TrimEnd('\0');
                        }

                        else
                        {
                            // replacedume an MDF file with the same name as the MDS
                        }

                        string dir = Path.GetDirectoryName(aFile.MDSPath);

                        if (f.FilenameOffset == 0 ||
                            string.Compare(fileName, "*.mdf", StringComparison.InvariantCultureIgnoreCase) == 0)
                        {
                            fileName = $@"{dir}\{Path.GetFileNameWithoutExtension(aFile.MDSPath)}.mdf";
                        }
                        else
                        {
                            fileName = $@"{dir}\{fileName}";
                        }

                        track.ImageFileNamePaths.Add(fileName);
                        track.ImageFileNamePaths = track.ImageFileNamePaths.Distinct().ToList();
                    }

                    stream.Position = currPos;


                    aTracks.Add(track.Point, track);
                    aFile.Tracks.Add(track);

                    if (footerOffset == 0)
                        footerOffset = track.FooterOffset;
                }
            }

            
            // build custom session object
            aFile.ParsedSession = new List<Session>();
            foreach (var s in aSessions.Values)
            {
                Session session = new Session();
                ATrack startTrack;
                ATrack endTrack;

                if (!aTracks.TryGetValue(s.FirstTrack, out startTrack))
                {
                    break;
                }

                if (!aTracks.TryGetValue(s.LastTrack, out endTrack))
                {
                    break;
                }

                session.StartSector = startTrack.PLBA;
                session.StartTrack = s.FirstTrack;
                session.SessionSequence = s.SessionNumber;
                session.EndSector = endTrack.PLBA + endTrack.ExtraBlock.Sectors - 1;
                session.EndTrack = s.LastTrack;

                aFile.ParsedSession.Add(session);
            }

			// now build the TOC object
			foreach (var se in aFile.ParsedSession)
				foreach (var t in aTracks.Values
					.Where(a => se.StartTrack <= a.TrackNo && a.TrackNo <= se.EndTrack)
					.OrderBy(a => a.TrackNo))
				{
					aFile.TOCEntries.Add(new ATOCEntry(t.Point)
					{
						ADR_Control = t.ADR_Control,
						AFrame = t.AFrame,
						AMin = t.AMin,
						ASec = t.ASec,
						BlobIndex = t.BlobIndex,
						EntryNum = t.TrackNo,
						ExtraBlock = t.ExtraBlock,
						ImageFileNamePaths = t.ImageFileNamePaths,
						PFrame = t.PFrame,
						PLBA = Convert.ToInt32(t.PLBA),
						PMin = t.PMin,
						Point = t.Point,
						PSec = t.PSec,
						SectorSize = t.SectorSize,
						Session = se.SessionSequence,
						TrackOffset = Convert.ToInt64(t.StartOffset),
						Zero = t.Zero
					});
				}

            return aFile;
        }

19 Source : ULongConvertor.cs
with GNU General Public License v3.0
from SeeSharpOpenSource

protected override void InitializeConvertFuncs()
        {
            ConvertFuncs.Add(typeof(decimal).Name, sourceValue => System.Convert.ToDecimal((ulong)sourceValue));
            ConvertFuncs.Add(typeof(double).Name, sourceValue => System.Convert.ToDouble((ulong)sourceValue));
            ConvertFuncs.Add(typeof(float).Name, sourceValue => System.Convert.ToSingle((ulong)sourceValue));
            ConvertFuncs.Add(typeof(long).Name, sourceValue => System.Convert.ToInt64((ulong)sourceValue));
//            ConvertFuncs.Add(typeof(ulong).Name, sourceValue => System.Convert.ToUInt64((ulong)sourceValue));
            ConvertFuncs.Add(typeof(int).Name, sourceValue => System.Convert.ToInt32((ulong)sourceValue));
            ConvertFuncs.Add(typeof(uint).Name, sourceValue => System.Convert.ToUInt32((ulong)sourceValue));
            ConvertFuncs.Add(typeof(short).Name, sourceValue => System.Convert.ToInt16((ulong)sourceValue));
            ConvertFuncs.Add(typeof(ushort).Name, sourceValue => System.Convert.ToUInt16((ulong)sourceValue));
            ConvertFuncs.Add(typeof(char).Name, sourceValue => System.Convert.ToChar((ulong)sourceValue));
            ConvertFuncs.Add(typeof(byte).Name, sourceValue => System.Convert.ToByte((ulong)sourceValue));
            ConvertFuncs.Add(typeof(bool).Name, sourceValue => (ulong)sourceValue > 0);
            ConvertFuncs.Add(typeof(string).Name, sourceValue => sourceValue.ToString());
        }

19 Source : CRC32.cs
with MIT License
from stefanounick

public long CRC(Stream st, long beginPosition, long length) 
		{
			ulong ulCRC = poly;
			long originalPos = st.Position;
			long endPos = beginPosition + length;
			byte by;

			if (endPos > st.Length) 
			{
				throw new Exception("Out of bounds. beginposition + length is greater than the length of the Stream");
			}

			try
			{
				st.Position = beginPosition;
				BufferedStream bs = new BufferedStream(st);
				
				for(long i = beginPosition; i < endPos; i++) 
				{ 
					by =  Convert.ToByte(bs.ReadByte());
					ulCRC = (ulCRC >> 8) ^ crcLookup[(ulCRC & 0xFF) ^ by];
				}
			}
			catch (Exception e)
			{
				Console.WriteLine(e.ToString());
			}
			finally
			{
			//For now do nothing
			}
			st.Position = originalPos;
			return Convert.ToInt64( ulCRC ^ poly); 
		}

19 Source : CRC32.cs
with MIT License
from stefanounick

public long CRC(byte[] by) 
		{
			ulong ulCRC = poly;
			long len;
			len = by.Length;
			for(long i = 0; i < len; i++) 
			{ 
				ulCRC = (ulCRC >> 8) ^ crcLookup[(ulCRC & 0xFF) ^ by[i]];
			}
			return Convert.ToInt64( ulCRC ^ poly); 
		}

19 Source : CRC32.cs
with MIT License
from stefanounick

public long EndByteCRC()
		{
			return Convert.ToInt64( m_CRC ^ poly);
		}

19 Source : UInt64.cs
with MIT License
from Team-RTCLI

long IConvertible.ToInt64(IFormatProvider? provider)
        {
            return Convert.ToInt64(m_value);
        }