using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using NUnit.Framework;
 
namespace MyProject
{
    [TestFixture]
    public class UtilityTest
    {
        [Test]
        public void FindConflictingReferences()
        {
            var assemblies = GetAllAssemblies(@"E:\dev\myapp\myproject\bin\debug");
 
            var references = GetReferencesFromAllAssemblies(assemblies);
 
            var groupsOfConflicts = FindReferencesWithTheSameShortNameButDiffererntFullNames(references);
 
            foreach (var group in groupsOfConflicts)
            {
                Console.Out.WriteLine("Possible conflicts for {0}:", group.Key);
                foreach (var reference in group)
                {
                    Console.Out.WriteLine("{0} references {1}",
                                          reference.Assembly.Name.PadRight(25),
                                          reference.ReferencedAssembly.FullName);
                }
            }
        }
 
        private IEnumerable<IGrouping<string, Reference>> FindReferencesWithTheSameShortNameButDiffererntFullNames(List<Reference> references)
        {
            return from reference in references
                   group reference by reference.ReferencedAssembly.Name
                       into referenceGroup
                       where referenceGroup.ToList().Select(reference => reference.ReferencedAssembly.FullName).Distinct().Count() > 1
                       select referenceGroup;
        }
 
        private List<Reference> GetReferencesFromAllAssemblies(List<Assembly> assemblies)
        {
            var references = new List<Reference>();
            foreach (var assembly in assemblies)
            {
                foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
                {
                    references.Add(new Reference
                    {
                        Assembly = assembly.GetName(),
                        ReferencedAssembly = referencedAssembly
                    });
                }
            }
            return references;
        }
 
        private List<Assembly> GetAllAssemblies(string path)
        {
            var files = new List<FileInfo>();
            var directoryToSearch = new DirectoryInfo(path);
            files.AddRange(directoryToSearch.GetFiles("*.dll", SearchOption.AllDirectories));
            files.AddRange(directoryToSearch.GetFiles("*.exe", SearchOption.AllDirectories));
            return files.ConvertAll(file => Assembly.LoadFile(file.FullName));
        }
 
        private class Reference
        {
            public AssemblyName Assembly { get; set; }
            public AssemblyName ReferencedAssembly { get; set; }
        }
 
    }
}

Imports System
Imports EnvDTE
Imports EnvDTE80
Imports EnvDTE90
Imports System.Diagnostics
 
Public Module Module1
 
    Public Sub BindShortcuts()
        Bind("ReSharper.ReSharper_UnitTest_ContextRun", "Alt+n")
        Bind("ReSharper.ReSharper_ShowUnitTestExplorer", "Ctrl+Alt+T")
        Bind("ReSharper.ReSharper_ShowUnitTestSessions", "Ctrl+Alt+R")
        Bind("ReSharper.ReSharper_UnitTest_RunCurrentSession", "Ctrl+Alt+E")
        Bind("File.CloseAllButThis", "Ctrl+Alt+Shift+W")
        MsgBox("Done.")
    End Sub
 
    Private Sub Bind(ByVal commandName As String, ByVal globalBinding As String)
        Dim command As Command
        command = DTE.Commands.Item(commandName, 1)
        command.Bindings = "Global::" & globalBinding
    End Sub
 
End Module

<target name="publish.webservice">
    <exec basedir="."
          program="${msbuild.exe}"
          commandline=" ${web.project.file}
                        /nologo
                        /p:OutDir=${publish.webservice.dir}bin
                        /p:WebProjectOutputDir=${publish.webservice.dir}"
          workingdir="."
          failonerror="true" />
</target>

CREATE OR REPLACE PROCEDURE reset_sequence (
seq_name IN VARCHAR2, startvalue IN PLS_INTEGER) AS
 
cval   INTEGER;
inc_by VARCHAR2(25);
 
BEGIN
  EXECUTE IMMEDIATE 'ALTER SEQUENCE ' ||seq_name||' MINVALUE 0';
 
  EXECUTE IMMEDIATE 'SELECT ' ||seq_name ||'.NEXTVAL FROM dual' INTO cval;
 
  cval := cval - startvalue + 1;
 
  IF cval = 0 THEN
    RETURN;
  ELSIF cval < 0 THEN 
    inc_by := ' INCREMENT BY ' || ABS(cval);
  ELSE
    inc_by := ' INCREMENT BY -' || cval;
  END IF; 
 
  EXECUTE IMMEDIATE 'ALTER SEQUENCE ' || seq_name || inc_by;
 
  EXECUTE IMMEDIATE 'SELECT ' ||seq_name ||'.NEXTVAL FROM dual' INTO cval;
 
  EXECUTE IMMEDIATE 'ALTER SEQUENCE ' || seq_name || ' INCREMENT BY 1';
 
END reset_sequence;
/
 
CREATE OR REPLACE PROCEDURE reset_sequence_from_table (
seq_name IN VARCHAR2, column_name IN VARCHAR2, table_name IN VARCHAR2) AS
 
cval   INTEGER;
 
BEGIN
 
  EXECUTE IMMEDIATE 'SELECT MAX(' || column_name ||') FROM ' || table_name 
  INTO cval;
 
  IF (cval IS NULL) THEN
    cval := 1;
  ELSE
    cval := cval + 1;
  END IF;
 
  RESET_SEQUENCE(seq_name, cval);
 
END reset_sequence_from_table;
/

DROP sequence mytable_seq;
DROP TABLE mytable;
 
CREATE TABLE mytable ( id NUMBER );
CREATE sequence mytable_seq;
 
INSERT INTO mytable VALUES (1);
INSERT INTO mytable VALUES (2);
INSERT INTO mytable VALUES (3);
INSERT INTO mytable VALUES (4);
INSERT INTO mytable VALUES (5);
INSERT INTO mytable VALUES (6);
INSERT INTO mytable VALUES (7);
INSERT INTO mytable VALUES (8);
INSERT INTO mytable VALUES (9);
INSERT INTO mytable VALUES (10);
 
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
SELECT mytable_seq.NEXTVAL FROM dual;
 
COMMIT;

exec reset_sequence_from_table('MYTABLE_SEQ', 'ID', 'MYTABLE');
 
-- should return 11 because mytable has a record with id 10
SELECT mytable_seq.NEXTVAL FROM dual;