asp.net core pdf editor : Drag and drop pdf into powerpoint application SDK utility azure wpf windows visual studio How%20to%20Use%20Word13-part1398

Getting To Grips With VBA Basics In 15 Minutes
20. If you want to work on a part of the active document then you have to start this way. 
(Remember: No one gets to the father except through me!) When you type the “.” at the 
end of the expression a list will pop up. This list is the most amazing guide you can 
imagine. Each item on the list is either a method or a property of the ActiveDocument or 
else it's an object unto itself that belongs to the ActiveDocument. For now let's deal with 
objects that belong to the ActiveDocument. 
An object is something that you can “work on” by applying methods to it or by changing 
its properties. Word documents contain lots of different types of objects. When multiple 
objects of the same type exist (or can exist) in the same document, they are treated as 
“collections.” For example, a word document has, or can have, multiple paragraphs. 
Each paragraph is an object. All of the paragraph objects, together, form the “paragraphs 
collection.” 
The easiest document objects (and collections) to think about are paragraphs, words, 
and characters. The way to think is this: “I'm trying to work on an object that belongs to 
the active document, namely a paragraph. Since a document can contain more than one 
paragraph, I'll have to locate the collection of paragraphs and then specify the specific 
paragraph that I want to work on. If I'm patient and scroll through this list, I'll almost 
certainly find the collection.” 
When you first think this way, the words “object” and “collection” will stick in your throat 
like a fishbone. Later it will feel more like burnt toast and later still it will feel like love 
when you hit puberty. Indeed, in this case, if you're patient, you will scroll far enough to 
encounter a collection called Paragraphs. Eureka! You know it's not a method because it 
doesn't have an icon next to it that looks like a green brick flying through the air. You 
don't think of it as a property, either, but you quickly find out that the VBA editor *does* 
think of it as a property. OK, OK. So one of the “properties” of a Word document is that it 
contains a collection of paragraphs. Great. So “Paragraphs” is a collection of paragraph 
objects and “Paragraphs” is a property of a Word document. This is confusing, so quit 
worrying about it. Focus on the list! Find the item you want to work on! 
Let's give it a try. Since you've scrolled down and selected Paragraphs, you can press 
Tab to accept it or you can double-click it right there in the list. Either way, your statement 
now looks as follows: 
ActiveDocument.Paragraphs 
21. So far so good. Most people easily get this far. But now what? A major wrinkle, that's 
what! But hold on, it's easy to deal with. Since “Paragraphs” is a collection, you have to 
tell the VBA editor which paragraph you're interested in. You do this with a number in 
parentheses. For example, (1) refers to the first paragraph. Let's assume you want to 
work on the first paragraph in the collection. Type until your statement looks like this: 
ActiveDocument.Paragraphs(1). 
22. Guess what? You've just “drilled down” from the ActiveDocument object to the 
Paragraphs collection to the first Paragraph. That is, you've “reached” or “specified” an 
object that you want to work on. From here on out, life is easy. Why? Because working 
on a paragraph object is just like working on a document object. As soon as you type the 
dot after the object, the VBA editor shows you a list of all the methods, properties, and 
objects (or collections of objects) that belong to *your* object. Simply select the method 
that you want to carry out on your object, or select the property that you want to change, 
or keep drilling down by selecting an object or collection that belongs to your object. 
That's all there is to it. 
A possible 23rd step would be to repeat Steps 1 -22 but replace all occurrences of 
“ActiveDocument.” with “Selection.” This allows you to drill down from the Selection 
object and discover the various methods, properties, and collections associated with the 
Selection object. 
A possible 24th step would be to repeat Steps 1 -22 but replace all occurrences of 
“ActiveDocument.” with “Application.” This allows you to drill down from the Word 
application object and discover the various methods, properties, and collections 
associated with that object. 
Send all feedback to word@mvps.org  
Top  - Ctrl+Home
Previous - Alt+left arrow
Page Updated: 
http://word.mvps.org/FAQs/MacrosVBA/VBABasicsIn15Mins.htm (4 of 4)10/16/09 5:41 PM
Drag and drop pdf into powerpoint - application SDK utility:C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in C#.net, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
www.rasteredge.com
Drag and drop pdf into powerpoint - application SDK utility:VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to PDF in vb.net, ASP.NET MVC, WinForms, WPF
VB.NET Tutorial for Export PDF file from Microsoft Office PowerPoint
www.rasteredge.com
The art of defensive programming
Microsoft Word MVP FAQ Site
Home 
Site Map 
Word:mac 
FAQ 
Tutorials 
Downloads 
Find Help 
Suggestions 
Links 
About Us 
Search
The art of defensive programming 
Or how to write code that will be easy to maintain 
Article contributed by Jonathan West 
The source code that you write has two quite separate purposes.
1. It is a set of instructions to the computer, telling it to perform a particular task.
2. It is a description of the task and how you have gone about executing the task, for 
yourself and/or other programmers.
This article is mainly about the second purpose, which a surprising number of people don't 
really think about.
If you can't understand a program, then you can't debug it. Even with code that you have 
written yourself, if you come back to it six months or a year later, you may find yourself 
wondering “Why on earth did I write that? What was it for?” It doesn't take long to forget the 
details of a program when you aren't working on it any more. Make life easier for yourself, and 
write programs as clearly as possible. Also, provide such defences as you can against the 
possibility that VBA might change between versions of Word.
The following example is based on a real question that came up in the newsgroups in 1999. 
The questioner wanted a macro that would do the following for a particular set of styles 
named “AGR1” to “AGR5”:- 
1. Check to see if the style already exists in the document.
2. If it does, then do nothing.
3. If it doesn't, then copy it from a central template.
This is a fairly common kind of problem that Word VBA macros are excellent at solving. The 
following code was suggested in response to the question. 
Dim StyleArray As Variant  
Dim StyleExists As Boolean 
Sub Numbering() 
With ActiveDocument 
.UpdateStylesOnOpen = False 
End With 
StyleArray = Array("AGR1", "AGR2", "AGR3", "AGR4", "AGR5") 
StyleExists = False 
For x = 0 To 
For Each oStyle In ActiveDocument.Styles 
If oStyle = StyleArray(x) Then 
StyleExists = True 
End If 
Next oStyle 
If StyleExists = False Then 
Application.OrganizerCopy _ 
Source:="C:\Program Files\Microsoft Office\" & _ 
"Templates\Final Numbering TDS.dot", _ 
Destination:=ActiveDocument, Name:=StyleArray(x), _ 
Object:=wdOrganizerObjectStyles 
End If 
StyleExists = False 
Next 
End Sub
Now, this code does the job, but there are lots of ways in which it could be made easier to 
read and understand, and less prone to future problems. Remember, source code isn't just 
there for the computer to execute. It is a message to yourself (or to the programmer who 
someday may have to come after you and maintain your code) as to what you were trying to 
achieve. If you make the code easy to read, then that helps you. Anyway, here is a set of 
improvements that could be made to the code.
http://word.mvps.org/FAQs/MacrosVBA/MaintainableCode.htm (1 of 3)10/16/09 5:42 PM
application SDK utility:Online Convert PowerPoint to PDF file. Best free online export
clicking on the blue button or drag-and-drop your pptx or ppt file into the drop area. Then just wait until the conversion from Powerpoint to PDF is complete
www.rasteredge.com
application SDK utility:C# Image: How to Use C# Code to Capture Document from Scanning
capture a multi-page document (including PDF, TIFF, Word Drag a SaveFileDialog from the Visual Studio Toolbox Uses should populate the drop-down box previously
www.rasteredge.com
The art of defensive programming
1. There is no need for the Dim statements to be module-level declarations. They aren't 
needed in any other routine. Therefore they should come after the Sub Numbering() 
statement, so that there is no confusion with any other routine which might happen to use 
the same variable names. People tend to re-use favored and meaningful names, so this 
problem can be significant.
2.
“Numbering” isn't a very meaningful name for the routine. It's always a good idea give a 
routine a name that clearly describes its purpose. Perhaps ImportAGRStyles  would be 
better.
3.
You should have the “Require Variable Declaration” checkbox set in the VBA Options 
dialog, so that there is an Option Explicit statement at the start of every module. That 
way, there is much less chance that VBA will interpret a typographical error in one of your 
variable assignments as the creation of an entirely new variable of type Variant. This 
being so, you would need Dim statements for x and oStyle, as Long Style respectively. 
See also Why variables should be declared properly.
4. With–End With statements are a good idea, but there isn't really any need to use them if 
you are only putting one item in between. If you have two or more lines between them, 
then yes, great idea, use them whenever you can.
5. When updating the code at some point in the future, you might want to add another one 
or two items to StyleArray. It would be quite likely that you would forget (at least initially) 
to change the limit value of x, so that it reflects the new size of the array. It is much easier 
to let VBA to remember for you, by using UBound(StyleArray). That will adjust 
automatically to the number of items you include using the Array function.
6. A speedup trick. In the For Each oStyle loop, once you find a case where you set 
StyleExists = True, you don't need to go round the loop any more times. Therefore you 
can add an Exit For statement to drop you out of the loop.
7.
Using If StyleExists = False Then is not very efficient. Better would be If Not StyleExists 
Then. In fact, for readability, better still would be to rename the variable StyleIsMissing 
and swap the True/False values round, so the line can now read If StyleIsMissing Then 
8.
You can reset the value of StyleExists (or StyleIsMissing, as we would be renaming it) 
just once at the start of the loop, rather than once outside and once at the end of the loop. 
Fewer lines of code means fewer places that bugs can creep in!
9.
I don't trust default properties of objects. It would be too easy for MS to change them 
between versions of Word and break something in my code. Therefore I would prefer to 
use oStyle.NameLocal rather than just oStyle when comparing its value with StyleArray
(x). We haven't been through enough versions of Word with VBA to find out whether this 
may be a common problem with MS, though a few things did change between Word 97 
and Word 2000. I would simply prefer to minimize the risk, especially as I think it 
improves readability. Similarly, in the OrganizerCopy command, it would be better to use 
ActiveDocument.FullName instead of just ActiveDocument.
10. Indenting the code so that it follows the structure of the If–Then statements and For–Next 
loops makes it much easier to understand where the loops and branches are. Also, it is a 
good idea to indent continuations of lines (perhaps by double the normal amount), so that 
it is quite clear that they are not new instructions. Also, it is common to indent everything 
except for comments and the lines which begin and end a routine.
11. When a few lines of code together are needed for a specific task, keep them together, 
and then put a blank line below to show that you are starting on a new task. That way, the 
eye more clearly sees what your design is. 
That's quite a few comments, they are longer than the code I've been discussing! However, 
with every line of code that you publish (by which I mean that will ever be seen by anyone 
other than yourself), you should be able to justify it as being about the best way it could be 
written. I have learned the need for this kind of coding discipline the hard way, by having to fix 
extremely nasty and obscure bugs. Also, I have learned that for longer running macros 
(though this particular macro should be over quickly) every speedup trick in the book is worth 
applying. The code with these changes would now look like this.
Option Explicit 
Sub ImportAGRStyles() 
Dim StyleArray As Variant 
Dim StyleIsMissing As Boolean 
Dim As Long 
Dim oStyle As Style 
ActiveDocument.UpdateStylesOnOpen = False 
StyleArray = Array("AGR1", "AGR2", "AGR3", "AGR4", "AGR5") 
For x = 0 To UBound(StyleArray) 
StyleIsMissing = True 
For Each oStyle In ActiveDocument.Styles 
If oStyle.NameLocal = StyleArray(x) Then 
StyleIsMissing = False 
Exit For 
http://word.mvps.org/FAQs/MacrosVBA/MaintainableCode.htm (2 of 3)10/16/09 5:42 PM
application SDK utility:C# PDF: PDF Document Viewer & Reader SDK for Windows Forms
adding WinViewer DLL into Visual Studio Toolbox, you can directly drag and drop the control you can easily open a file dialog and load your PDF document in
www.rasteredge.com
application SDK utility:Online Convert Word to PDF file. Best free online export docx, doc
your file by clicking on the blue button or drag-and-drop your doc or docx file into the drop area. By integrating XDoc.PDF SDK into your C#.NET project
www.rasteredge.com
The art of defensive programming
End If 
Next oStyle 
If StyleIsMissing Then 
Application.OrganizerCopy _ 
Source:="C:\Program Files\Microsoft Office\" & _ 
"Templates\Final Numbering TDS.dot", _ 
Destination:=ActiveDocument.FullName, _ 
Name:=StyleArray(x), _ 
Object:=wdOrganizerObjectStyles 
End If 
Next 
End Sub
Note that both versions of the routine do exactly the same thing. Maybe the second is 
marginally faster, but not to an extent that really matters. However, the second is much safer 
because the layout is clearer, the variables are local, and default properties are not used. It is 
no harder to write like this, once you get into the habit. For a short macro like this, perhaps it 
doesn't matter so much, but once you start writing macros, you will probably think of more 
complex tasks that you can automate with them. Then the “defensive” approach can make a 
big difference to the length of time it takes to get things right.
There's one other thing to notice. I didn't put any comments in. For a routine that's as simple 
as this, if the code is written well, there shouldn't be any need for comments. At most, you 
might want a line or two at the start to describe the purpose of the routine. (You might also 
have other “standard” comments describing the author and revision level of the routine, but 
that's another issue altogether.) For a longer routine or a particularly obscure bit of code, it's 
probably a good idea to include a few extra comments at strategic points. These comments 
should aim to explain what you are trying to do, rather than how you are doing it. Once you 
know the what, the how should be clear from the code itself, and so doesn't need duplication. 
Recommended further reading.
If you want a much fuller treatment of this subject, I would very strongly recommend that you 
buy a copy of Code Complete, by Steve McConnell, published 1993 by Microsoft Press, ISBN 
1-55615-484-4. The book was written before Word VBA existed, and even before Visual Basic 
existed, and so its examples are mainly in C, Pascal and some in BASIC. Despite this, it 
contains the best set of guidelines I have come across for writing good code in any language. 
It covers most of the points I have made in this article, in much greater depth than I possibly 
could here. The book is beautifully clear (just like code should be!), and you will have no 
difficulty following the examples, whichever language they are written in.
Send all feedback to word@mvps.org  
Top  - Ctrl+Home
Previous - Alt+left arrow
Page Updated: 
http://word.mvps.org/FAQs/MacrosVBA/MaintainableCode.htm (3 of 3)10/16/09 5:42 PM
application SDK utility:VB.NET Image: VB Tutorial to View Document Online with Imaging Web
including png, jpeg, gif, tiff, bmp, PDF, Microsoft Word Drag your WebThumnailViewer & WebAnnotationViewer from your MS a new document when the drop-down list
www.rasteredge.com
application SDK utility:VB.NET Image: Capture and View Document Through Scanning in VB.NET
to your Visual Studio Toolbox and drag an OpenFileDialog Users must populate the drop-down box with powerful & profession imaging controls, PDF document, image
www.rasteredge.com
Why variables should be declared properly
Microsoft Word MVP FAQ Site
Home 
Site Map 
Word:mac 
FAQ 
Tutorials 
Downloads 
Find Help 
Suggestions 
Links 
About Us 
Search
Why variables should be declared properly
Article contributed by Dave Rado 
Almost all variables should be dimensioned as whatever they are (Dim MyRange As Range, 
Dim MyString As String, etc.), for several reasons: 
1. Otherwise you can sometimes get unexpected results 
2. Your code will run much faster and use less memory 
3. You'll then have access to intellisense – for instance, if you type MyRange, and then type 
a dot, a list of all properties and methods supported by the range object will pop up – 
provided that MyRange was Dim'd as a Range.  You can then cursor to the one you 
want and press Return (or select it with the mouse) to insert it. 
4. 
It makes debugging far easier, because the VBA Editor will then be able to “spot” errors it 
would otherwise miss. 
To force yourself to explicitly dimension all variables, your code window should have the line 
“Option Explicit” at the top of it.  Select Tools + Options;  and tick the “Require variable 
declaration” checkbox.  This will have the effect of inserting “Option Explicit” at the top of all 
new modules you create.  Doing this will give you all of the above benefits plus one more: 
5. It makes debugging far easier in another way, because if you accidentally misspell a 
variable name somewhere, this will be picked up as an undeclared variable if you compile 
your project (Debug menu). 
Important note: In order to explicityly declare variables, each one must be declared 
separately. For example, the statement: 
Dim Str1, Str2 As String 
is declaring all except the final one as a Variant, not as a string! You must declare each 
variable explicitly, as in: 
Dim Str1 As String, Str2 As String 
Or: 
Dim Str1As String  
Dim Str1 As String 
Send all feedback to word@mvps.org  
Top  - Ctrl+Home
Previous - Alt+left arrow
Page Updated: 
http://word.mvps.org/FAQs/MacrosVBA/DeclareVariables.htm10/16/09 5:42 PM
application SDK utility:How to C#: Quick to Start Using XImage.Raster
Add necessary XImage.Raster DLL libraries into your created C# application as references. RasterEdge.Imaging.Basic.dll. Just drag and drop the “ImageView
www.rasteredge.com
application SDK utility:How to C#: Set Image Thumbnail in C#.NET
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff, VB.NET Imaging, VB.NET OCR, VB.NET Just drag and drop the “ImageView
www.rasteredge.com
How to cut out repetition and write much less code, by using subroutines and functions that take arguments
Microsoft Word MVP FAQ Site
Home 
Site Map 
Word:mac 
FAQ 
Tutorials 
Downloads 
Find Help 
Suggestions 
Links 
About Us 
Search
How to cut out repetition and write much less 
code, by using subroutines and functions 
that take arguments
Article contributed by Dave Rado 
Most of us write routines that do similar operations more than once. It makes your code much 
less cumbersome and much easier to follow if you hive off all such repetitive chunks of code 
into separate subroutines or functions .
The difference between a sub and a function is that a function can return a value. Within the 
function itself, you can treat the function name like a variable, and give it a value and then you 
can call the function and get that value. Here's a ridiculously simple (and not very useful!) 
example:
Function GetResult As Long 
GetResult = 2 
End Function
Sub Test() 
MsgBox GetResult 
'Returns 2  
End Sub
But suppose you want to do a calculation 2 + 2. You could use:
MyResult = 2 + 2.
But alternatively, you could use a function to do the operation. The advantage is: less 
repetitive code (not so much in this example, because it's so simple, but in general).
So you could have:
Function SumTwoValues(FirstNum As Long, SecondNum As LongAs Long 
'Any sub or function can have variables passed to it, 
'and these variables, which need to be declared as shown here, enclosed in brackets 
'are called arguments 
SumTwoValues = FirstNum + SecondNum 
End Function
And you can call the function like this:
Sub MainMacro() 
Dim MyResult As Long 
MyResult = SumTwoValues(2, 2) 
End Sub
That's exactly the same as MyResult = 2 + 2, but if the function contained more than just one 
line of code, and was called often, using a function like that would greatly reduce the amount 
of code needed and also make your code easier to follow.
Let's take a more complex example. Supposing you had a macro that needs to do many Find 
and Replace operations, one after another. By using a subroutine that takes arguments to do 
the Find and Replaces it means you only need to have a single line of code for each and 
Replace. Here's a simple example:
Let's suppose that all your Find & Replace operations are identical except for the find text and 
replacement text. Then you could have a sub or function that gets called, which looks 
something like this:
Sub DoFindReplace(FindText As String, ReplaceText As String
http://word.mvps.org/FAQs/MacrosVBA/ProcArguments.htm (1 of 3)10/16/09 5:42 PM
application SDK utility:VB.NET Image: Web Image and Document Viewer Creation & Design
It is easy to drag and drop thumbnail images to for VB.NET can be used to view and print such documents and images as JPEG, BMP, GIF, PNG, TIFF, PDF, etc.
www.rasteredge.com
application SDK utility:Install Winforms .NET Imaging SDK| Online Tutorials
Drag and drop controls right onto your Design PRODUCTS: XDoc.HTML5 Viewer for .NET; XDoc.Windows Viewer for .NET; XDoc.Converter for .NET; XDoc.PDF for .NET;
www.rasteredge.com
How to cut out repetition and write much less code, by using subroutines and functions that take arguments
With Selection.Find 
.ClearFormatting 
.Replacement.ClearFormatting 
.Text = FindText 
.Replacement.Text = ReplaceText 
.Forward = True 
.Wrap = wdFindContinue 
.Format = False 
.MatchCase = False 
.MatchWholeWord = False 
.MatchWildcards = False 
.MatchSoundsLike = False 
.MatchAllWordForms = False 
Do While .Execute 
'Keep going until nothing found 
.Execute Replace:=wdReplaceAll 
Loop 
'Free up some memory 
ActiveDocument.UndoClear 
End With 
End Sub
You can then call it like this:
Sub MainMacro() 
'Remove double spaces 
Call DoFindReplace("  ", " ") 
'Remove all double tabs 
  Call DoFindReplace("^t^t", "^t") 
  'Remove empty paras (unless they folow a table or start or finish a doc) 
Call DoFindReplace("^p^p", "^p") 
'etc etc 
End Sub
So only one extra line is needed for each Find and Replace operation.
You can make it a bit more flexible by making any other parameters (such as .MatchCase)  
that might change from one find & replace operaration to the next into arguments that you can 
pass values to, instead of hard coding them. 
For instance, if .MatchCase is always set to False in your macro, you can just hard code it as 
shown above; but if it's True for some and False for others then you could use:
Sub DoFindReplace(FindText As String, ReplaceText As String, _ 
bMatchCase As Boolean
'rest of sub as before except 
.MatchCase = bMatchCase 
End Sub
and you could call that like this:
Sub MainMacro() 
Call DoFindReplace("Ibm", "IBMI", True) 
Call DoFindReplace("laserjet", "LaserJet", False) 
End Sub
With Subs and Functions that take arguments – as with Word's Methods (which are actually 
built-in functions) – you can choose whether or not to specify the variable names when you 
call them. In the examples given so far I haven't used the variable names in the calling 
statements; and in the first few examples, there was no real point, because it's obvious what's 
going on in them.
But in the last example, it's not so obvious what the third variable is (without looking at 
the function) – so it's better to specify the variable names in this case, which you do like this:
Sub MainMacro() 
Call DoFindReplace(FindText:="Ibm", ReplaceText:="IBM", bMatchCase:=True) 
Call DoFindReplace(FindText:="laserjet", ReplaceText:="LaserJet", bMatchCase:=False) 
End Sub
That is much easier to follow, for anyone maintaining your code, than
Call DoFindReplace("Ibm", "IBMI", True) 
Call DoFindReplace("laserjet", "LaserJet", False)
Sometimes you might want to specify an argument in a sub or function, but you might want it 
to be optional. Most built-in Word functions include some optional arguments (such as the 
Background argument of the Printout method, for instance).
http://word.mvps.org/FAQs/MacrosVBA/ProcArguments.htm (2 of 3)10/16/09 5:42 PM
How to cut out repetition and write much less code, by using subroutines and functions that take arguments
To make an argument optional, you simply prefix it with the keyword Optional when you 
declare it, for example:
Sub DoFindOrReplace(FindText As StringOptional ReplaceText As String)
In this example, the procedure could check the value of the optional ReplaceText variable; 
and do a Find & Replace if it had a value, but a Find if it didn't.
With optional arguments, you can also specify what value the variable should have if no value 
is specified. In other words you can specify its default value. If you do that, it's not optional in 
quite the same sense as before; it's actually mandatory, but you just don't have to specify its 
value in your code. If you don't specify its value, it will use the default value. So for example, 
you could have:
Sub DoFindReplace(FindText As String, ReplaceText As String, _ 
Optional bMatchCase As Boolean = False)
Then you'd only have to specify the value of the bMatchCase argument if you wanted it to be 
set to True. This can save a lot of typing!
Related articles
For some code examples which call subs or functions with arguments:
How to use a single VBA procedure to read or write both custom and built-in Document 
Properties
How to get the username of the current user
Getting names of available printers
How to find out, using VBA, how many replacements Word made during a Find & 
Replace All
Finding and replacing symbols
Other related tips:
The art of defensive programming
Why variables should be declared properly
Send all feedback to word@mvps.org  
Top  - Ctrl+Home
Previous - Alt+left arrow
Page Updated: 
http://word.mvps.org/FAQs/MacrosVBA/ProcArguments.htm (3 of 3)10/16/09 5:42 PM
When to use parentheses to enclose subroutine and function arguments
Microsoft Word MVP FAQ Site
Home 
Site Map 
Word:mac 
FAQ 
Tutorials 
Downloads 
Find Help 
Suggestions 
Links 
About Us 
Search
When to use parentheses to enclose 
subroutine and function arguments 
Article contributed by Jonathan West 
The rules are confusing concerning the use of parentheses to enclose argument lists. I have 
even seen MS Knowledgebase articles that have got it wrong. The rules are as follows.
1. For the initial line of a Sub or Function, you use parentheses to enclose the arguments (if 
any), e.g.
Sub MySubroutine(a As Long, b As String)
or
Function MyFunction(a As Long, B As StringAs Long
2. When calling a function, you use parentheses to enclose the arguments, like this.
x = MyFunction(a:=1, b:="abc")
or
x = MyFunction(1, "abc")
3. When calling a sub directly, you don't use parentheses, like this.
MySub a:=1, b:="abc"
or
MySub 1, "abc"
4. When calling a sub using the Call keyword, you do use parentheses (this made sense to 
somebody!)
Call MySub(a:=1, b:="abc")
or
Call MySub(1, "abc")
Note that it doesn't matter whether or not you use the Call keyword to call a subroutine. 
The effect on the program is identical whether or not you use Call (assuming you have 
the parentheses right). Most of the code on this site doesn't use Call, simply because it is 
fewer words to type.
5. When dealing with methods of an object, use the same rules, depending on whether you 
are obtaining a return value from the method (like a function), or just applying the method 
to the object without a return value (like a subroutine). For example, on the one hand:
Selection.GoTo What:=wdGoToPage, Name:="5"
But on the other hand (because you're now using a function which returns a value):
Dim MyRange As Range 
Set MyRange = ActiveDocument.Range 
Set MyRange = MyRange.GoTo(What:=wdGoToPage, Name:="5")
Send all feedback to word@mvps.org  
Top  - Ctrl+Home
Previous - Alt+left arrow
Page Updated: 
http://word.mvps.org/FAQs/MacrosVBA/BracketsWithArgmnts.htm10/16/09 5:43 PM
Early vs. Late Binding
l
Up to Office inter-development
m
Control Outlook from Word
m
Control PowerPoint from 
Word
m
Control Word from Excel
m
Control Excel from Word
m
Disable macros
m
Early vs. Late Binding
m
Load a ListBox from Excel
m
Insert database data
m
Microsoft Word MVP FAQ
m
Speeding up automation
m
Send an email from Word
m
Toolbars not showing
m
Bug: Instance conflict
m
Retrieving from Excel Named 
Range
Early vs. Late Binding
Article contributed by 
Dave Rado
There are two ways to use Automation (or OLE Automation) to 
programmatically control another application.
Late binding uses CreateObject to create and instance of the 
application object, which you can then control. For example, to 
create a new instance of Excel using late binding:
Dim oXL As Object  
Set oXL = CreateObject("Excel.Application")
On the other hand, to manipulate an existing instance of Excel (if 
Excel is already open) you would use GetObject (regardless 
whether you're using early or late binding):
Dim oXL As Object  
Set oXL = GetObject(, "Excel.Application")
To use early binding, you first need to set a reference in your 
project to the application you want to manipulate. In the VB Editor 
of any Office application, or in VB itself, you do this by selecting 
Tools + References, and selecting the application you want from 
the list (e.g. “Microsoft Excel 8.0 Object Library”). 
To create a new instance of Excel using early binding: 
Dim oXL As Excel.Application  
Set oXL = New Excel.Application
In either case, incidentally, you can first try to get an existing 
instance of Excel, and if that returns an error, you can create a 
new instance in your error handler. 
Advantages of Early Binding
Word HomeWord:mac Word General TroubleshootTutorialsAbout 
UsContact
http://word.mvps.org/FAQs/InterDev/EarlyvsLateBinding.htm (1 of 4)10/16/09 5:43 PM
Documents you may be interested
Documents you may be interested